esphome 2025.9.3__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/psram/__init__.py

@@ -62,6 +62,11 @@ SPIRAM_SPEEDS = {
 }
 
 
+def supported() -> bool:
+    variant = get_esp32_variant()
+    return variant in SPIRAM_MODES
+
+
 def validate_psram_mode(config):
     esp32_config = fv.full_config.get()[PLATFORM_ESP32]
     if config[CONF_SPEED] == "120MHZ":
@@ -95,7 +100,7 @@ def get_config_schema(config):
     variant = get_esp32_variant()
     speeds = [f"{s}MHZ" for s in SPIRAM_SPEEDS.get(variant, [])]
     if not speeds:
-        return cv.Invalid("PSRAM is not supported on this chip")
+        raise cv.Invalid("PSRAM is not supported on this chip")
     modes = SPIRAM_MODES[variant]
     return cv.Schema(
         {
@@ -121,33 +126,30 @@ async def to_code(config):
         if config[CONF_MODE] == TYPE_OCTAL:
             cg.add_platformio_option("board_build.arduino.memory_type", "qio_opi")
 
-    if CORE.using_esp_idf:
-        add_idf_sdkconfig_option(
-            f"CONFIG_{get_esp32_variant().upper()}_SPIRAM_SUPPORT", True
-        )
-        add_idf_sdkconfig_option("CONFIG_SOC_SPIRAM_SUPPORTED", True)
-        add_idf_sdkconfig_option("CONFIG_SPIRAM", True)
-        add_idf_sdkconfig_option("CONFIG_SPIRAM_USE", True)
-        add_idf_sdkconfig_option("CONFIG_SPIRAM_USE_CAPS_ALLOC", True)
-        add_idf_sdkconfig_option("CONFIG_SPIRAM_IGNORE_NOTFOUND", True)
-
-        add_idf_sdkconfig_option(
-            f"CONFIG_SPIRAM_MODE_{SDK_MODES[config[CONF_MODE]]}", True
-        )
-
-        # Remove MHz suffix, convert to int
-        speed = int(config[CONF_SPEED][:-3])
-        add_idf_sdkconfig_option(f"CONFIG_SPIRAM_SPEED_{speed}M", True)
-        add_idf_sdkconfig_option("CONFIG_SPIRAM_SPEED", speed)
-        if config[CONF_MODE] == TYPE_OCTAL and speed == 120:
-            add_idf_sdkconfig_option("CONFIG_ESPTOOLPY_FLASHFREQ_120M", True)
-            add_idf_sdkconfig_option("CONFIG_BOOTLOADER_FLASH_DC_AWARE", True)
-            if CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(5, 4, 0):
-                add_idf_sdkconfig_option(
-                    "CONFIG_SPIRAM_TIMING_TUNING_POINT_VIA_TEMPERATURE_SENSOR", True
-                )
-        if config[CONF_ENABLE_ECC]:
-            add_idf_sdkconfig_option("CONFIG_SPIRAM_ECC_ENABLE", True)
+    add_idf_sdkconfig_option(
+        f"CONFIG_{get_esp32_variant().upper()}_SPIRAM_SUPPORT", True
+    )
+    add_idf_sdkconfig_option("CONFIG_SOC_SPIRAM_SUPPORTED", True)
+    add_idf_sdkconfig_option("CONFIG_SPIRAM", True)
+    add_idf_sdkconfig_option("CONFIG_SPIRAM_USE", True)
+    add_idf_sdkconfig_option("CONFIG_SPIRAM_USE_CAPS_ALLOC", True)
+    add_idf_sdkconfig_option("CONFIG_SPIRAM_IGNORE_NOTFOUND", True)
+
+    add_idf_sdkconfig_option(f"CONFIG_SPIRAM_MODE_{SDK_MODES[config[CONF_MODE]]}", True)
+
+    # Remove MHz suffix, convert to int
+    speed = int(config[CONF_SPEED][:-3])
+    add_idf_sdkconfig_option(f"CONFIG_SPIRAM_SPEED_{speed}M", True)
+    add_idf_sdkconfig_option("CONFIG_SPIRAM_SPEED", speed)
+    if config[CONF_MODE] == TYPE_OCTAL and speed == 120:
+        add_idf_sdkconfig_option("CONFIG_ESPTOOLPY_FLASHFREQ_120M", True)
+        add_idf_sdkconfig_option("CONFIG_BOOTLOADER_FLASH_DC_AWARE", True)
+        if CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(5, 4, 0):
+            add_idf_sdkconfig_option(
+                "CONFIG_SPIRAM_TIMING_TUNING_POINT_VIA_TEMPERATURE_SENSOR", True
+            )
+    if config[CONF_ENABLE_ECC]:
+        add_idf_sdkconfig_option("CONFIG_SPIRAM_ECC_ENABLE", True)
 
     cg.add_define("USE_PSRAM")
 

esphome/components/qmc5883l/qmc5883l.cpp

@@ -8,6 +8,7 @@ namespace esphome {
 namespace qmc5883l {
 
 static const char *const TAG = "qmc5883l";
+
 static const uint8_t QMC5883L_ADDRESS = 0x0D;
 
 static const uint8_t QMC5883L_REGISTER_DATA_X_LSB = 0x00;
@@ -32,6 +33,10 @@ void QMC5883LComponent::setup() {
   }
   delay(10);
 
+  if (this->drdy_pin_) {
+    this->drdy_pin_->setup();
+  }
+
   uint8_t control_1 = 0;
   control_1 |= 0b01 << 0;  // MODE (Mode) -> 0b00=standby, 0b01=continuous
   control_1 |= this->datarate_ << 2;
@@ -64,6 +69,7 @@ void QMC5883LComponent::setup() {
     high_freq_.start();
   }
 }
+
 void QMC5883LComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "QMC5883L:");
   LOG_I2C_DEVICE(this);
@@ -77,11 +83,20 @@ void QMC5883LComponent::dump_config() {
   LOG_SENSOR("  ", "Z Axis", this->z_sensor_);
   LOG_SENSOR("  ", "Heading", this->heading_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_PIN("  DRDY Pin: ", this->drdy_pin_);
 }
+
 float QMC5883LComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void QMC5883LComponent::update() {
   i2c::ErrorCode err;
   uint8_t status = false;
+
+  // If DRDY pin is configured and the data is not ready return.
+  if (this->drdy_pin_ && !this->drdy_pin_->digital_read()) {
+    return;
+  }
+
   // Status byte gets cleared when data is read, so we have to read this first.
   // If status and two axes are desired, it's possible to save one byte of traffic by enabling
   // ROL_PNT in setup and reading 7 bytes starting at the status register.

esphome/components/qmc5883l/qmc5883l.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace qmc5883l {
@@ -33,6 +34,7 @@ class QMC5883LComponent : public PollingComponent, public i2c::I2CDevice {
   float get_setup_priority() const override;
   void update() override;
 
+  void set_drdy_pin(GPIOPin *pin) { drdy_pin_ = pin; }
   void set_datarate(QMC5883LDatarate datarate) { datarate_ = datarate; }
   void set_range(QMC5883LRange range) { range_ = range; }
   void set_oversampling(QMC5883LOversampling oversampling) { oversampling_ = oversampling; }
@@ -51,6 +53,7 @@ class QMC5883LComponent : public PollingComponent, public i2c::I2CDevice {
   sensor::Sensor *z_sensor_{nullptr};
   sensor::Sensor *heading_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
+  GPIOPin *drdy_pin_{nullptr};
   enum ErrorCode {
     NONE = 0,
     COMMUNICATION_FAILED,

esphome/components/qmc5883l/sensor.py

@@ -1,8 +1,12 @@
+import logging
+
+from esphome import pins
 import esphome.codegen as cg
 from esphome.components import i2c, sensor
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
+    CONF_DATA_RATE,
     CONF_FIELD_STRENGTH_X,
     CONF_FIELD_STRENGTH_Y,
     CONF_FIELD_STRENGTH_Z,
@@ -21,6 +25,10 @@ from esphome.const import (
     UNIT_MICROTESLA,
 )
 
+_LOGGER = logging.getLogger(__name__)
+
+CONF_DRDY_PIN = "drdy_pin"
+
 DEPENDENCIES = ["i2c"]
 
 qmc5883l_ns = cg.esphome_ns.namespace("qmc5883l")
@@ -52,6 +60,18 @@ QMC5883LOversamplings = {
 }
 
 
+def validate_config(config):
+    if (
+        config[CONF_UPDATE_INTERVAL].total_milliseconds < 15
+        and CONF_DRDY_PIN not in config
+    ):
+        _LOGGER.warning(
+            "[qmc5883l] 'update_interval' is less than 15ms and 'drdy_pin' is "
+            "not configured, this may result in I2C errors"
+        )
+    return config
+
+
 def validate_enum(enum_values, units=None, int=True):
     _units = []
     if units is not None:
@@ -88,7 +108,7 @@ temperature_schema = sensor.sensor_schema(
     state_class=STATE_CLASS_MEASUREMENT,
 )
 
-CONFIG_SCHEMA = (
+CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(QMC5883LComponent),
@@ -104,29 +124,25 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_FIELD_STRENGTH_Z): field_strength_schema,
             cv.Optional(CONF_HEADING): heading_schema,
             cv.Optional(CONF_TEMPERATURE): temperature_schema,
+            cv.Optional(CONF_DRDY_PIN): pins.gpio_input_pin_schema,
+            cv.Optional(CONF_DATA_RATE, default="200hz"): validate_enum(
+                QMC5883LDatarates, units=["hz", "Hz"]
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x0D))
+    .extend(i2c.i2c_device_schema(0x0D)),
+    validate_config,
 )
 
 
-def auto_data_rate(config):
-    interval_sec = config[CONF_UPDATE_INTERVAL].total_milliseconds / 1000
-    interval_hz = 1.0 / interval_sec
-    for datarate in sorted(QMC5883LDatarates.keys()):
-        if float(datarate) >= interval_hz:
-            return QMC5883LDatarates[datarate]
-    return QMC5883LDatarates[200]
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
 
     cg.add(var.set_oversampling(config[CONF_OVERSAMPLING]))
-    cg.add(var.set_datarate(auto_data_rate(config)))
+    cg.add(var.set_datarate(config[CONF_DATA_RATE]))
     cg.add(var.set_range(config[CONF_RANGE]))
     if CONF_FIELD_STRENGTH_X in config:
         sens = await sensor.new_sensor(config[CONF_FIELD_STRENGTH_X])
@@ -143,3 +159,6 @@ async def to_code(config):
     if CONF_TEMPERATURE in config:
         sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
         cg.add(var.set_temperature_sensor(sens))
+    if CONF_DRDY_PIN in config:
+        pin = await cg.gpio_pin_expression(config[CONF_DRDY_PIN])
+        cg.add(var.set_drdy_pin(pin))

esphome/components/remote_base/gobox_protocol.cpp

@@ -10,8 +10,8 @@ constexpr uint32_t BIT_MARK_US = 580;  // 70us seems like a safe time delta for
 constexpr uint32_t BIT_ONE_SPACE_US = 1640;
 constexpr uint32_t BIT_ZERO_SPACE_US = 545;
 constexpr uint64_t HEADER = 0b011001001100010uL;  // 15 bits
-constexpr uint64_t HEADER_SIZE = 15;
-constexpr uint64_t CODE_SIZE = 17;
+constexpr size_t HEADER_SIZE = 15;
+constexpr size_t CODE_SIZE = 17;
 
 void GoboxProtocol::dump_timings_(const RawTimings &timings) const {
   ESP_LOGD(TAG, "Gobox: size=%u", timings.size());
@@ -39,7 +39,7 @@ void GoboxProtocol::encode(RemoteTransmitData *dst, const GoboxData &data) {
 }
 
 optional<GoboxData> GoboxProtocol::decode(RemoteReceiveData src) {
-  if (src.size() < ((HEADER_SIZE + CODE_SIZE) * 2 + 1)) {
+  if (static_cast<size_t>(src.size()) < ((HEADER_SIZE + CODE_SIZE) * 2 + 1)) {
     return {};
   }
 

esphome/components/remote_receiver/__init__.py

@@ -5,6 +5,8 @@ from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
+    CONF_CARRIER_DUTY_PERCENT,
+    CONF_CARRIER_FREQUENCY,
     CONF_CLOCK_RESOLUTION,
     CONF_DUMP,
     CONF_FILTER,
@@ -149,6 +151,14 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
                 ),
                 cv.boolean,
             ),
+            cv.SplitDefault(CONF_CARRIER_DUTY_PERCENT, esp32=100): cv.All(
+                cv.only_on_esp32,
+                cv.percentage_int,
+                cv.Range(min=1, max=100),
+            ),
+            cv.SplitDefault(CONF_CARRIER_FREQUENCY, esp32="0Hz"): cv.All(
+                cv.only_on_esp32, cv.frequency, cv.int_
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -168,6 +178,8 @@ async def to_code(config):
             cg.add(var.set_clock_resolution(config[CONF_CLOCK_RESOLUTION]))
         if CONF_FILTER_SYMBOLS in config:
             cg.add(var.set_filter_symbols(config[CONF_FILTER_SYMBOLS]))
+        cg.add(var.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))
+        cg.add(var.set_carrier_frequency(config[CONF_CARRIER_FREQUENCY]))
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
 
@@ -196,8 +208,8 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
-        "remote_receiver_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "remote_receiver_libretiny.cpp": {
+        "remote_receiver.cpp": {
+            PlatformFramework.ESP8266_ARDUINO,
             PlatformFramework.BK72XX_ARDUINO,
             PlatformFramework.RTL87XX_ARDUINO,
             PlatformFramework.LN882X_ARDUINO,

esphome/components/remote_receiver/{remote_receiver_esp8266.cpp → remote_receiver.cpp}

@@ -3,12 +3,12 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ESP8266
+#if defined(USE_LIBRETINY) || defined(USE_ESP8266)
 
 namespace esphome {
 namespace remote_receiver {
 
-static const char *const TAG = "remote_receiver.esp8266";
+static const char *const TAG = "remote_receiver";
 
 void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverComponentStore *arg) {
   const uint32_t now = micros();

esphome/components/remote_receiver/remote_receiver.h

@@ -64,6 +64,8 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
   void set_filter_symbols(uint32_t filter_symbols) { this->filter_symbols_ = filter_symbols; }
   void set_receive_symbols(uint32_t receive_symbols) { this->receive_symbols_ = receive_symbols; }
   void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
+  void set_carrier_duty_percent(uint8_t carrier_duty_percent) { this->carrier_duty_percent_ = carrier_duty_percent; }
+  void set_carrier_frequency(uint32_t carrier_frequency) { this->carrier_frequency_ = carrier_frequency; }
 #endif
   void set_buffer_size(uint32_t buffer_size) { this->buffer_size_ = buffer_size; }
   void set_filter_us(uint32_t filter_us) { this->filter_us_ = filter_us; }
@@ -76,6 +78,8 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
   uint32_t filter_symbols_{0};
   uint32_t receive_symbols_{0};
   bool with_dma_{false};
+  uint32_t carrier_frequency_{0};
+  uint8_t carrier_duty_percent_{100};
   esp_err_t error_code_{ESP_OK};
   std::string error_string_{""};
 #endif

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -72,6 +72,21 @@ void RemoteReceiverComponent::setup() {
     return;
   }
 
+  if (this->carrier_frequency_ > 0 && 0 < this->carrier_duty_percent_ && this->carrier_duty_percent_ < 100) {
+    rmt_carrier_config_t carrier;
+    memset(&carrier, 0, sizeof(carrier));
+    carrier.frequency_hz = this->carrier_frequency_;
+    carrier.duty_cycle = (float) this->carrier_duty_percent_ / 100.0f;
+    carrier.flags.polarity_active_low = this->pin_->is_inverted();
+    error = rmt_apply_carrier(this->channel_, &carrier);
+    if (error != ESP_OK) {
+      this->error_code_ = error;
+      this->error_string_ = "in rmt_apply_carrier";
+      this->mark_failed();
+      return;
+    }
+  }
+
   rmt_rx_event_callbacks_t callbacks;
   memset(&callbacks, 0, sizeof(callbacks));
   callbacks.on_recv_done = rmt_callback;
@@ -111,11 +126,13 @@ void RemoteReceiverComponent::dump_config() {
                 "  Filter symbols: %" PRIu32 "\n"
                 "  Receive symbols: %" PRIu32 "\n"
                 "  Tolerance: %" PRIu32 "%s\n"
+                "  Carrier frequency: %" PRIu32 " hz\n"
+                "  Carrier duty: %u%%\n"
                 "  Filter out pulses shorter than: %" PRIu32 " us\n"
                 "  Signal is done after %" PRIu32 " us of no changes",
                 this->clock_resolution_, this->rmt_symbols_, this->filter_symbols_, this->receive_symbols_,
                 this->tolerance_, (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? " us" : "%",
-                this->filter_us_, this->idle_us_);
+                this->carrier_frequency_, this->carrier_duty_percent_, this->filter_us_, this->idle_us_);
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Configuring RMT driver failed: %s (%s)", esp_err_to_name(this->error_code_),
              this->error_string_.c_str());

esphome/components/remote_transmitter/__init__.py

@@ -131,8 +131,8 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
-        "remote_transmitter_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
-        "remote_transmitter_libretiny.cpp": {
+        "remote_transmitter.cpp": {
+            PlatformFramework.ESP8266_ARDUINO,
             PlatformFramework.BK72XX_ARDUINO,
             PlatformFramework.RTL87XX_ARDUINO,
             PlatformFramework.LN882X_ARDUINO,

esphome/components/remote_transmitter/remote_transmitter.cpp

@@ -2,10 +2,113 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 
+#if defined(USE_LIBRETINY) || defined(USE_ESP8266)
+
 namespace esphome {
 namespace remote_transmitter {
 
 static const char *const TAG = "remote_transmitter";
 
+void RemoteTransmitterComponent::setup() {
+  this->pin_->setup();
+  this->pin_->digital_write(false);
+}
+
+void RemoteTransmitterComponent::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Remote Transmitter:\n"
+                "  Carrier Duty: %u%%",
+                this->carrier_duty_percent_);
+  LOG_PIN("  Pin: ", this->pin_);
+}
+
+void RemoteTransmitterComponent::calculate_on_off_time_(uint32_t carrier_frequency, uint32_t *on_time_period,
+                                                        uint32_t *off_time_period) {
+  if (carrier_frequency == 0) {
+    *on_time_period = 0;
+    *off_time_period = 0;
+    return;
+  }
+  uint32_t period = (1000000UL + carrier_frequency / 2) / carrier_frequency;  // round(1000000/freq)
+  period = std::max(uint32_t(1), period);
+  *on_time_period = (period * this->carrier_duty_percent_) / 100;
+  *off_time_period = period - *on_time_period;
+}
+
+void RemoteTransmitterComponent::await_target_time_() {
+  const uint32_t current_time = micros();
+  if (this->target_time_ == 0) {
+    this->target_time_ = current_time;
+  } else if ((int32_t) (this->target_time_ - current_time) > 0) {
+#if defined(USE_LIBRETINY)
+    // busy loop for libretiny is required (see the comment inside micros() in wiring.c)
+    while ((int32_t) (this->target_time_ - micros()) > 0)
+      ;
+#else
+    delayMicroseconds(this->target_time_ - current_time);
+#endif
+  }
+}
+
+void RemoteTransmitterComponent::mark_(uint32_t on_time, uint32_t off_time, uint32_t usec) {
+  this->await_target_time_();
+  this->pin_->digital_write(true);
+
+  const uint32_t target = this->target_time_ + usec;
+  if (this->carrier_duty_percent_ < 100 && (on_time > 0 || off_time > 0)) {
+    while (true) {  // Modulate with carrier frequency
+      this->target_time_ += on_time;
+      if ((int32_t) (this->target_time_ - target) >= 0)
+        break;
+      this->await_target_time_();
+      this->pin_->digital_write(false);
+
+      this->target_time_ += off_time;
+      if ((int32_t) (this->target_time_ - target) >= 0)
+        break;
+      this->await_target_time_();
+      this->pin_->digital_write(true);
+    }
+  }
+  this->target_time_ = target;
+}
+
+void RemoteTransmitterComponent::space_(uint32_t usec) {
+  this->await_target_time_();
+  this->pin_->digital_write(false);
+  this->target_time_ += usec;
+}
+
+void RemoteTransmitterComponent::digital_write(bool value) { this->pin_->digital_write(value); }
+
+void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
+  ESP_LOGD(TAG, "Sending remote code");
+  uint32_t on_time, off_time;
+  this->calculate_on_off_time_(this->temp_.get_carrier_frequency(), &on_time, &off_time);
+  this->target_time_ = 0;
+  this->transmit_trigger_->trigger();
+  for (uint32_t i = 0; i < send_times; i++) {
+    InterruptLock lock;
+    for (int32_t item : this->temp_.get_data()) {
+      if (item > 0) {
+        const auto length = uint32_t(item);
+        this->mark_(on_time, off_time, length);
+      } else {
+        const auto length = uint32_t(-item);
+        this->space_(length);
+      }
+      App.feed_wdt();
+    }
+    this->await_target_time_();  // wait for duration of last pulse
+    this->pin_->digital_write(false);
+
+    if (i + 1 < send_times)
+      this->target_time_ += send_wait;
+  }
+  this->complete_trigger_->trigger();
+}
+
 }  // namespace remote_transmitter
 }  // namespace esphome
+
+#endif

esphome/components/rp2040/__init__.py

@@ -1,5 +1,5 @@
 import logging
-import os
+from pathlib import Path
 from string import ascii_letters, digits
 
 import esphome.codegen as cg
@@ -19,7 +19,7 @@ from esphome.const import (
     ThreadModel,
 )
 from esphome.core import CORE, CoroPriority, EsphomeError, coroutine_with_priority
-from esphome.helpers import copy_file_if_changed, mkdir_p, read_file, write_file
+from esphome.helpers import copy_file_if_changed, read_file, write_file_if_changed
 
 from .const import KEY_BOARD, KEY_PIO_FILES, KEY_RP2040, rp2040_ns
 
@@ -221,18 +221,18 @@ def generate_pio_files() -> bool:
     if not files:
         return False
     for key, data in files.items():
-        pio_path = CORE.relative_build_path(f"src/pio/{key}.pio")
-        mkdir_p(os.path.dirname(pio_path))
-        write_file(pio_path, data)
+        pio_path = CORE.build_path / "src" / "pio" / f"{key}.pio"
+        pio_path.parent.mkdir(parents=True, exist_ok=True)
+        write_file_if_changed(pio_path, data)
         includes.append(f"pio/{key}.pio.h")
 
-    write_file(
+    write_file_if_changed(
         CORE.relative_build_path("src/pio_includes.h"),
         "#pragma once\n" + "\n".join([f'#include "{include}"' for include in includes]),
     )
 
-    dir = os.path.dirname(__file__)
-    build_pio_file = os.path.join(dir, "build_pio.py.script")
+    dir = Path(__file__).parent
+    build_pio_file = dir / "build_pio.py.script"
     copy_file_if_changed(
         build_pio_file,
         CORE.relative_build_path("build_pio.py"),
@@ -243,8 +243,8 @@ def generate_pio_files() -> bool:
 
 # Called by writer.py
 def copy_files():
-    dir = os.path.dirname(__file__)
-    post_build_file = os.path.join(dir, "post_build.py.script")
+    dir = Path(__file__).parent
+    post_build_file = dir / "post_build.py.script"
     copy_file_if_changed(
         post_build_file,
         CORE.relative_build_path("post_build.py"),
@@ -252,4 +252,4 @@ def copy_files():
     if generate_pio_files():
         path = CORE.relative_src_path("esphome.h")
         content = read_file(path).rstrip("\n")
-        write_file(path, content + '\n#include "pio_includes.h"\n')
+        write_file_if_changed(path, content + '\n#include "pio_includes.h"\n')

esphome/components/rtttl/rtttl.cpp

@@ -215,7 +215,7 @@ void Rtttl::loop() {
           sample[x].right = 0;
         }
 
-        if (x >= SAMPLE_BUFFER_SIZE || this->samples_sent_ >= this->samples_count_) {
+        if (static_cast<size_t>(x) >= SAMPLE_BUFFER_SIZE || this->samples_sent_ >= this->samples_count_) {
           break;
         }
         this->samples_sent_++;
@@ -374,7 +374,7 @@ void Rtttl::loop() {
   this->last_note_ = millis();
 }
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
 static const LogString *state_to_string(State state) {
   switch (state) {
     case STATE_STOPPED:

esphome/components/scd30/sensor.py

@@ -66,7 +66,7 @@ CONFIG_SCHEMA = (
             ),
             cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION, default=0): cv.pressure,
             cv.Optional(CONF_TEMPERATURE_OFFSET): cv.All(
-                cv.temperature,
+                cv.temperature_delta,
                 cv.float_range(min=0, max=655.35),
             ),
             cv.Optional(CONF_UPDATE_INTERVAL, default="60s"): cv.All(

esphome/components/script/__init__.py

@@ -124,7 +124,7 @@ async def to_code(config):
         template, func_args = parameters_to_template(conf[CONF_PARAMETERS])
         trigger = cg.new_Pvariable(conf[CONF_ID], template)
         # Add a human-readable name to the script
-        cg.add(trigger.set_name(conf[CONF_ID].id))
+        cg.add(trigger.set_name(cg.LogStringLiteral(conf[CONF_ID].id)))
 
         if CONF_MAX_RUNS in conf:
             cg.add(trigger.set_max_runs(conf[CONF_MAX_RUNS]))

esphome/components/script/script.h

@@ -48,14 +48,14 @@ template<typename... Ts> class Script : public ScriptLogger, public Trigger<Ts..
   }
 
   // Internal function to give scripts readable names.
-  void set_name(const std::string &name) { name_ = name; }
+  void set_name(const LogString *name) { name_ = name; }
 
  protected:
   template<int... S> void execute_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->execute(std::get<S>(tuple)...);
   }
 
-  std::string name_;
+  const LogString *name_{nullptr};
 };
 
 /** A script type for which only a single instance at a time is allowed.
@@ -68,7 +68,7 @@ template<typename... Ts> class SingleScript : public Script<Ts...> {
   void execute(Ts... x) override {
     if (this->is_action_running()) {
       this->esp_logw_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' is already running! (mode: single)"),
-                      this->name_.c_str());
+                      LOG_STR_ARG(this->name_));
       return;
     }
 
@@ -85,7 +85,7 @@ template<typename... Ts> class RestartScript : public Script<Ts...> {
  public:
   void execute(Ts... x) override {
     if (this->is_action_running()) {
-      this->esp_logd_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' restarting (mode: restart)"), this->name_.c_str());
+      this->esp_logd_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' restarting (mode: restart)"), LOG_STR_ARG(this->name_));
       this->stop_action();
     }
 
@@ -105,12 +105,12 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
       // num_runs_ + 1
       if (this->max_runs_ != 0 && this->num_runs_ + 1 >= this->max_runs_) {
         this->esp_logw_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' maximum number of queued runs exceeded!"),
-                        this->name_.c_str());
+                        LOG_STR_ARG(this->name_));
         return;
       }
 
       this->esp_logd_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' queueing new instance (mode: queued)"),
-                      this->name_.c_str());
+                      LOG_STR_ARG(this->name_));
       this->num_runs_++;
       this->var_queue_.push(std::make_tuple(x...));
       return;
@@ -157,7 +157,7 @@ template<typename... Ts> class ParallelScript : public Script<Ts...> {
   void execute(Ts... x) override {
     if (this->max_runs_ != 0 && this->automation_parent_->num_running() >= this->max_runs_) {
       this->esp_logw_(__LINE__, ESPHOME_LOG_FORMAT("Script '%s' maximum number of parallel runs exceeded!"),
-                      this->name_.c_str());
+                      LOG_STR_ARG(this->name_));
       return;
     }
     this->trigger(x...);