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

esphome/components/select/select.cpp

@@ -34,11 +34,12 @@ size_t Select::size() const {
 
 optional<size_t> Select::index_of(const std::string &option) const {
   const auto &options = traits.get_options();
-  auto it = std::find(options.begin(), options.end(), option);
-  if (it == options.end()) {
-    return {};
+  for (size_t i = 0; i < options.size(); i++) {
+    if (options[i] == option) {
+      return i;
+    }
   }
-  return std::distance(options.begin(), it);
+  return {};
 }
 
 optional<size_t> Select::active_index() const {

esphome/components/select/select_call.cpp

@@ -107,7 +107,7 @@ void SelectCall::perform() {
     }
   }
 
-  if (std::find(options.begin(), options.end(), target_value) == options.end()) {
+  if (!parent->has_option(target_value)) {
     ESP_LOGW(TAG, "'%s' - Option %s is not a valid option", name, target_value.c_str());
     return;
   }

esphome/components/sensirion_common/i2c_sensirion.cpp

@@ -76,7 +76,8 @@ bool SensirionI2CDevice::write_command_(uint16_t command, CommandLen command_len
     temp[raw_idx++] = data[i] >> 8;
 #endif
     // Use MSB first since Sensirion devices use CRC-8 with MSB first
-    temp[raw_idx++] = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
+    uint8_t crc = crc8(&temp[raw_idx - 2], 2, 0xFF, CRC_POLYNOMIAL, true);
+    temp[raw_idx++] = crc;
   }
   this->last_error_ = this->write(temp, raw_idx);
   return this->last_error_ == i2c::ERROR_OK;

esphome/components/sensor/__init__.py

@@ -74,6 +74,7 @@ from esphome.const import (
     DEVICE_CLASS_OZONE,
     DEVICE_CLASS_PH,
     DEVICE_CLASS_PM1,
+    DEVICE_CLASS_PM4,
     DEVICE_CLASS_PM10,
     DEVICE_CLASS_PM25,
     DEVICE_CLASS_POWER,
@@ -143,6 +144,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_PM1,
     DEVICE_CLASS_PM10,
     DEVICE_CLASS_PM25,
+    DEVICE_CLASS_PM4,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_PRECIPITATION,

esphome/components/sha256/__init__.py

@@ -0,0 +1,22 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.core import CORE
+from esphome.helpers import IS_MACOS
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@esphome/core"]
+
+sha256_ns = cg.esphome_ns.namespace("sha256")
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+async def to_code(config: ConfigType) -> None:
+    # Add OpenSSL library for host platform
+    if not CORE.is_host:
+        return
+    if IS_MACOS:
+        # macOS needs special handling for Homebrew OpenSSL
+        cg.add_build_flag("-I/opt/homebrew/opt/openssl/include")
+        cg.add_build_flag("-L/opt/homebrew/opt/openssl/lib")
+    cg.add_build_flag("-lcrypto")

esphome/components/sha256/sha256.cpp

@@ -0,0 +1,116 @@
+#include "sha256.h"
+
+// Only compile SHA256 implementation on platforms that support it
+#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_HOST)
+
+#include "esphome/core/helpers.h"
+#include <cstring>
+
+namespace esphome::sha256 {
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+
+// CRITICAL ESP32-S3 HARDWARE SHA ACCELERATION REQUIREMENTS:
+//
+// The ESP32-S3 uses hardware DMA for SHA acceleration. The mbedtls_sha256_context structure contains
+// internal state that the DMA engine references. This imposes two critical constraints:
+//
+// 1. NO VARIABLE LENGTH ARRAYS (VLAs): VLAs corrupt the stack layout, causing the DMA engine to
+//    write to incorrect memory locations. This results in null pointer dereferences and crashes.
+//    ALWAYS use fixed-size arrays (e.g., char buf[65], not char buf[size+1]).
+//
+// 2. SAME STACK FRAME ONLY: The SHA256 object must be created and used entirely within the same
+//    function. NEVER pass the SHA256 object or HashBase pointer to another function. When the stack
+//    frame changes (function call/return), the DMA references become invalid and will produce
+//    truncated hash output (20 bytes instead of 32) or corrupt memory.
+//
+// CORRECT USAGE:
+//   void my_function() {
+//     sha256::SHA256 hasher;  // Created locally
+//     hasher.init();
+//     hasher.add(data, len);  // Any size, no chunking needed
+//     hasher.calculate();
+//     bool ok = hasher.equals_hex(expected);
+//     // hasher destroyed when function returns
+//   }
+//
+// INCORRECT USAGE (WILL FAIL ON ESP32-S3):
+//   void my_function() {
+//     sha256::SHA256 hasher;
+//     helper(&hasher);  // WRONG: Passed to different stack frame
+//   }
+//   void helper(HashBase *h) {
+//     h->init();  // WRONG: Will produce truncated/corrupted output
+//   }
+
+SHA256::~SHA256() { mbedtls_sha256_free(&this->ctx_); }
+
+void SHA256::init() {
+  mbedtls_sha256_init(&this->ctx_);
+  mbedtls_sha256_starts(&this->ctx_, 0);  // 0 = SHA256, not SHA224
+}
+
+void SHA256::add(const uint8_t *data, size_t len) { mbedtls_sha256_update(&this->ctx_, data, len); }
+
+void SHA256::calculate() { mbedtls_sha256_finish(&this->ctx_, this->digest_); }
+
+#elif defined(USE_ESP8266) || defined(USE_RP2040)
+
+SHA256::~SHA256() = default;
+
+void SHA256::init() {
+  br_sha256_init(&this->ctx_);
+  this->calculated_ = false;
+}
+
+void SHA256::add(const uint8_t *data, size_t len) { br_sha256_update(&this->ctx_, data, len); }
+
+void SHA256::calculate() {
+  if (!this->calculated_) {
+    br_sha256_out(&this->ctx_, this->digest_);
+    this->calculated_ = true;
+  }
+}
+
+#elif defined(USE_HOST)
+
+SHA256::~SHA256() {
+  if (this->ctx_) {
+    EVP_MD_CTX_free(this->ctx_);
+  }
+}
+
+void SHA256::init() {
+  if (this->ctx_) {
+    EVP_MD_CTX_free(this->ctx_);
+  }
+  this->ctx_ = EVP_MD_CTX_new();
+  EVP_DigestInit_ex(this->ctx_, EVP_sha256(), nullptr);
+  this->calculated_ = false;
+}
+
+void SHA256::add(const uint8_t *data, size_t len) {
+  if (!this->ctx_) {
+    this->init();
+  }
+  EVP_DigestUpdate(this->ctx_, data, len);
+}
+
+void SHA256::calculate() {
+  if (!this->ctx_) {
+    this->init();
+  }
+  if (!this->calculated_) {
+    unsigned int len = 32;
+    EVP_DigestFinal_ex(this->ctx_, this->digest_, &len);
+    this->calculated_ = true;
+  }
+}
+
+#else
+#error "SHA256 not supported on this platform"
+#endif
+
+}  // namespace esphome::sha256
+
+#endif  // Platform check

esphome/components/sha256/sha256.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+// Only define SHA256 on platforms that support it
+#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_HOST)
+
+#include <cstdint>
+#include <string>
+#include <memory>
+#include "esphome/core/hash_base.h"
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+#include "mbedtls/sha256.h"
+#elif defined(USE_ESP8266) || defined(USE_RP2040)
+#include <bearssl/bearssl_hash.h>
+#elif defined(USE_HOST)
+#include <openssl/evp.h>
+#else
+#error "SHA256 not supported on this platform"
+#endif
+
+namespace esphome::sha256 {
+
+class SHA256 : public esphome::HashBase {
+ public:
+  SHA256() = default;
+  ~SHA256() override;
+
+  void init() override;
+  void add(const uint8_t *data, size_t len) override;
+  using HashBase::add;  // Bring base class overload into scope
+  void add(const std::string &data) { this->add((const uint8_t *) data.c_str(), data.length()); }
+
+  void calculate() override;
+
+  /// Get the size of the hash in bytes (32 for SHA256)
+  size_t get_size() const override { return 32; }
+
+ protected:
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  // CRITICAL: The mbedtls context MUST be stack-allocated (not a pointer) for ESP32-S3 hardware SHA acceleration.
+  // The ESP32-S3 DMA engine references this structure's memory addresses. If the context is passed to another
+  // function (crossing stack frames) or if VLAs are present, the DMA operations will corrupt memory and produce
+  // truncated/incorrect hash results.
+  mbedtls_sha256_context ctx_{};
+#elif defined(USE_ESP8266) || defined(USE_RP2040)
+  br_sha256_context ctx_{};
+  bool calculated_{false};
+#elif defined(USE_HOST)
+  EVP_MD_CTX *ctx_{nullptr};
+  bool calculated_{false};
+#else
+#error "SHA256 not supported on this platform"
+#endif
+};
+
+}  // namespace esphome::sha256
+
+#endif  // Platform check

esphome/components/socket/lwip_raw_tcp_impl.cpp

@@ -9,7 +9,7 @@
 #include "lwip/tcp.h"
 #include <cerrno>
 #include <cstring>
-#include <queue>
+#include <array>
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -50,12 +50,18 @@ class LWIPRawImpl : public Socket {
       errno = EBADF;
       return nullptr;
     }
-    if (accepted_sockets_.empty()) {
+    if (this->accepted_socket_count_ == 0) {
       errno = EWOULDBLOCK;
       return nullptr;
     }
-    std::unique_ptr<LWIPRawImpl> sock = std::move(accepted_sockets_.front());
-    accepted_sockets_.pop();
+    // Take from front for FIFO ordering
+    std::unique_ptr<LWIPRawImpl> sock = std::move(this->accepted_sockets_[0]);
+    // Shift remaining sockets forward
+    for (uint8_t i = 1; i < this->accepted_socket_count_; i++) {
+      this->accepted_sockets_[i - 1] = std::move(this->accepted_sockets_[i]);
+    }
+    this->accepted_socket_count_--;
+    LWIP_LOG("Connection accepted by application, queue size: %d", this->accepted_socket_count_);
     if (addr != nullptr) {
       sock->getpeername(addr, addrlen);
     }
@@ -494,9 +500,18 @@ class LWIPRawImpl : public Socket {
       // nothing to do here, we just don't push it to the queue
       return ERR_OK;
     }
+    // Check if we've reached the maximum accept queue size
+    if (this->accepted_socket_count_ >= MAX_ACCEPTED_SOCKETS) {
+      LWIP_LOG("Rejecting connection, queue full (%d)", this->accepted_socket_count_);
+      // Abort the connection when queue is full
+      tcp_abort(newpcb);
+      // Must return ERR_ABRT since we called tcp_abort()
+      return ERR_ABRT;
+    }
     auto sock = make_unique<LWIPRawImpl>(family_, newpcb);
     sock->init();
-    accepted_sockets_.push(std::move(sock));
+    this->accepted_sockets_[this->accepted_socket_count_++] = std::move(sock);
+    LWIP_LOG("Accepted connection, queue size: %d", this->accepted_socket_count_);
     return ERR_OK;
   }
   void err_fn(err_t err) {
@@ -587,7 +602,20 @@ class LWIPRawImpl : public Socket {
   }
 
   struct tcp_pcb *pcb_;
-  std::queue<std::unique_ptr<LWIPRawImpl>> accepted_sockets_;
+  // Accept queue - holds incoming connections briefly until the event loop calls accept()
+  // This is NOT a connection pool - just a temporary queue between LWIP callbacks and the main loop
+  // 3 slots is plenty since connections are pulled out quickly by the event loop
+  //
+  // Memory analysis: std::array<3> vs original std::queue implementation:
+  // - std::queue uses std::deque internally which on 32-bit systems needs:
+  //   24 bytes (deque object) + 32+ bytes (map array) + heap allocations
+  //   Total: ~56+ bytes minimum, plus heap fragmentation
+  // - std::array<3>: 12 bytes fixed (3 pointers × 4 bytes)
+  // Saves ~44+ bytes RAM per listening socket + avoids ALL heap allocations
+  // Used on ESP8266 and RP2040 (platforms using LWIP_TCP implementation)
+  static constexpr size_t MAX_ACCEPTED_SOCKETS = 3;
+  std::array<std::unique_ptr<LWIPRawImpl>, MAX_ACCEPTED_SOCKETS> accepted_sockets_;
+  uint8_t accepted_socket_count_ = 0;  // Number of sockets currently in queue
   bool rx_closed_ = false;
   pbuf *rx_buf_ = nullptr;
   size_t rx_buf_offset_ = 0;

esphome/components/sonoff_d1/sonoff_d1.cpp

@@ -50,7 +50,7 @@ static const char *const TAG = "sonoff_d1";
 
 uint8_t SonoffD1Output::calc_checksum_(const uint8_t *cmd, const size_t len) {
   uint8_t crc = 0;
-  for (int i = 2; i < len - 1; i++) {
+  for (size_t i = 2; i < len - 1; i++) {
     crc += cmd[i];
   }
   return crc;

esphome/components/spi/__init__.py

@@ -276,9 +276,6 @@ def get_spi_interface(index):
         return ["&SPI", "&SPI1"][index]
     if index == 0:
         return "&SPI"
-    # Following code can't apply to C2, H2 or 8266 since they have only one SPI
-    if get_target_variant() in (VARIANT_ESP32S3, VARIANT_ESP32S2):
-        return "new SPIClass(FSPI)"
     return "new SPIClass(HSPI)"
 
 

esphome/components/split_buffer/__init__.py

@@ -0,0 +1,5 @@
+CODEOWNERS = ["@jesserockz"]
+
+# Allows split_buffer to be configured in yaml, to allow use of the C++ api.
+
+CONFIG_SCHEMA = {}

esphome/components/split_buffer/split_buffer.cpp

@@ -0,0 +1,133 @@
+#include "split_buffer.h"
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome::split_buffer {
+
+static constexpr const char *const TAG = "split_buffer";
+
+SplitBuffer::~SplitBuffer() { this->free(); }
+
+bool SplitBuffer::init(size_t total_length) {
+  this->free();  // Clean up any existing allocation
+
+  if (total_length == 0) {
+    return false;
+  }
+
+  this->total_length_ = total_length;
+  size_t current_buffer_size = total_length;
+
+  RAMAllocator<uint8_t *> ptr_allocator;
+  RAMAllocator<uint8_t> allocator;
+
+  // Try to allocate the entire buffer first
+  while (current_buffer_size > 0) {
+    // Calculate how many buffers we need of this size
+    size_t needed_buffers = (total_length + current_buffer_size - 1) / current_buffer_size;
+
+    // Try to allocate array of buffer pointers
+    uint8_t **temp_buffers = ptr_allocator.allocate(needed_buffers);
+    if (temp_buffers == nullptr) {
+      // If we can't even allocate the pointer array, don't need to continue
+      ESP_LOGE(TAG, "Failed to allocate pointers");
+      return false;
+    }
+
+    // Initialize all pointers to null
+    for (size_t i = 0; i < needed_buffers; i++) {
+      temp_buffers[i] = nullptr;
+    }
+
+    // Try to allocate all the buffers
+    bool allocation_success = true;
+    for (size_t i = 0; i < needed_buffers; i++) {
+      size_t this_buffer_size = current_buffer_size;
+      // Last buffer might be smaller if total_length is not divisible by current_buffer_size
+      if (i == needed_buffers - 1 && total_length % current_buffer_size != 0) {
+        this_buffer_size = total_length % current_buffer_size;
+      }
+
+      temp_buffers[i] = allocator.allocate(this_buffer_size);
+      if (temp_buffers[i] == nullptr) {
+        allocation_success = false;
+        break;
+      }
+
+      // Initialize buffer to zero
+      memset(temp_buffers[i], 0, this_buffer_size);
+    }
+
+    if (allocation_success) {
+      // Success! Store the result
+      this->buffers_ = temp_buffers;
+      this->buffer_count_ = needed_buffers;
+      this->buffer_size_ = current_buffer_size;
+      ESP_LOGD(TAG, "Allocated %zu * %zu bytes - %zu bytes", this->buffer_count_, this->buffer_size_,
+               this->total_length_);
+      return true;
+    }
+
+    // Allocation failed, clean up and try smaller buffers
+    for (size_t i = 0; i < needed_buffers; i++) {
+      if (temp_buffers[i] != nullptr) {
+        allocator.deallocate(temp_buffers[i], 0);
+      }
+    }
+    ptr_allocator.deallocate(temp_buffers, 0);
+
+    // Halve the buffer size and try again
+    current_buffer_size = current_buffer_size / 2;
+  }
+
+  ESP_LOGE(TAG, "Failed to allocate %zu bytes", total_length);
+  return false;
+}
+
+void SplitBuffer::free() {
+  if (this->buffers_ != nullptr) {
+    RAMAllocator<uint8_t> allocator;
+    for (size_t i = 0; i < this->buffer_count_; i++) {
+      if (this->buffers_[i] != nullptr) {
+        allocator.deallocate(this->buffers_[i], 0);
+      }
+    }
+    RAMAllocator<uint8_t *> ptr_allocator;
+    ptr_allocator.deallocate(this->buffers_, 0);
+    this->buffers_ = nullptr;
+  }
+  this->buffer_count_ = 0;
+  this->buffer_size_ = 0;
+  this->total_length_ = 0;
+}
+
+uint8_t &SplitBuffer::operator[](size_t index) {
+  if (index >= this->total_length_) {
+    ESP_LOGE(TAG, "Out of bounds - %zu >= %zu", index, this->total_length_);
+    // Return reference to a static dummy byte to avoid crash
+    static uint8_t dummy = 0;
+    return dummy;
+  }
+
+  size_t buffer_index = index / this->buffer_size_;
+  size_t offset_in_buffer = index - this->buffer_size_ * buffer_index;
+
+  return this->buffers_[buffer_index][offset_in_buffer];
+}
+
+const uint8_t &SplitBuffer::operator[](size_t index) const {
+  if (index >= this->total_length_) {
+    ESP_LOGE(TAG, "Out of bounds - %zu >= %zu", index, this->total_length_);
+    // Return reference to a static dummy byte to avoid crash
+    static const uint8_t DUMMY = 0;
+    return DUMMY;
+  }
+
+  size_t buffer_index = index / this->buffer_size_;
+  size_t offset_in_buffer = index - this->buffer_size_ * buffer_index;
+
+  return this->buffers_[buffer_index][offset_in_buffer];
+}
+
+}  // namespace esphome::split_buffer

esphome/components/split_buffer/split_buffer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+
+namespace esphome::split_buffer {
+
+class SplitBuffer {
+ public:
+  SplitBuffer() = default;
+  ~SplitBuffer();
+
+  // Initialize the buffer with the desired total length
+  bool init(size_t total_length);
+
+  // Free all allocated buffers
+  void free();
+
+  // Access operators
+  uint8_t &operator[](size_t index);
+  const uint8_t &operator[](size_t index) const;
+
+  // Get the total length
+  size_t size() const { return this->total_length_; }
+
+  // Get buffer information
+  size_t get_buffer_count() const { return this->buffer_count_; }
+  size_t get_buffer_size() const { return this->buffer_size_; }
+
+  // Check if successfully initialized
+  bool is_valid() const { return this->buffers_ != nullptr && this->buffer_count_ > 0; }
+
+ private:
+  uint8_t **buffers_{nullptr};
+  size_t buffer_count_{0};
+  size_t buffer_size_{0};
+  size_t total_length_{0};
+};
+
+}  // namespace esphome::split_buffer

esphome/components/sps30/sps30.cpp

@@ -52,17 +52,19 @@ void SPS30Component::setup() {
     } else {
       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)) {
-        this->fan_interval_ = secs[0] << 16 | secs[1];
-      }
-    }
 
-    this->status_clear_warning();
-    this->skipped_data_read_cycles_ = 0;
-    this->start_continuous_measurement_();
+    this->set_timeout(20, [this, result]() {
+      if (result) {
+        uint16_t secs[2];
+        if (this->read_data(secs, 2)) {
+          this->fan_interval_ = secs[0] << 16 | secs[1];
+        }
+      }
+      this->status_clear_warning();
+      this->skipped_data_read_cycles_ = 0;
+      this->start_continuous_measurement_();
+      this->setup_complete_ = true;
+    });
   });
 }
 
@@ -111,6 +113,8 @@ void SPS30Component::dump_config() {
 }
 
 void SPS30Component::update() {
+  if (!this->setup_complete_)
+    return;
   /// Check if warning flag active (sensor reconnected?)
   if (this->status_has_warning()) {
     ESP_LOGD(TAG, "Reconnecting");

esphome/components/sps30/sps30.h

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

esphome/components/st7567_i2c/st7567_i2c.cpp

@@ -50,8 +50,10 @@ void HOT I2CST7567::write_display_data() {
 
     static const size_t BLOCK_SIZE = 64;
     for (uint8_t x = 0; x < (uint8_t) this->get_width_internal(); x += BLOCK_SIZE) {
+      size_t remaining = static_cast<size_t>(this->get_width_internal()) - x;
+      size_t chunk = remaining > BLOCK_SIZE ? BLOCK_SIZE : remaining;
       this->write_register(esphome::st7567_base::ST7567_SET_START_LINE, &buffer_[y * this->get_width_internal() + x],
-                           this->get_width_internal() - x > BLOCK_SIZE ? BLOCK_SIZE : this->get_width_internal() - x);
+                           chunk);
     }
   }
 }

esphome/components/st7789v/st7789v.cpp

@@ -176,8 +176,9 @@ void ST7789V::write_display_data() {
   if (this->eightbitcolor_) {
     uint8_t temp_buffer[TEMP_BUFFER_SIZE];
     size_t temp_index = 0;
-    for (int line = 0; line < this->get_buffer_length_(); line = line + this->get_width_internal()) {
-      for (int index = 0; index < this->get_width_internal(); ++index) {
+    size_t width = static_cast<size_t>(this->get_width_internal());
+    for (size_t line = 0; line < this->get_buffer_length_(); line += width) {
+      for (size_t index = 0; index < width; ++index) {
         auto color = display::ColorUtil::color_to_565(
             display::ColorUtil::to_color(this->buffer_[index + line], display::ColorOrder::COLOR_ORDER_RGB,
                                          display::ColorBitness::COLOR_BITNESS_332, true));

esphome/components/statsd/statsd.cpp

@@ -151,7 +151,7 @@ void StatsdComponent::send_(std::string *out) {
 
   int n_bytes = this->sock_->sendto(out->c_str(), out->length(), 0, reinterpret_cast<sockaddr *>(&this->destination_),
                                     sizeof(this->destination_));
-  if (n_bytes != out->length()) {
+  if (n_bytes != static_cast<int>(out->length())) {
     ESP_LOGE(TAG, "Failed to send UDP packed (%d of %d)", n_bytes, out->length());
   }
 #endif

esphome/components/substitutions/__init__.py

@@ -4,7 +4,7 @@ from esphome import core
 from esphome.config_helpers import Extend, Remove, merge_config
 import esphome.config_validation as cv
 from esphome.const import CONF_SUBSTITUTIONS, VALID_SUBSTITUTIONS_CHARACTERS
-from esphome.yaml_util import ESPHomeDataBase, make_data_base
+from esphome.yaml_util import ESPHomeDataBase, ESPLiteralValue, make_data_base
 
 from .jinja import Jinja, JinjaStr, TemplateError, TemplateRuntimeError, has_jinja
 
@@ -127,6 +127,8 @@ def _expand_substitutions(substitutions, value, path, jinja, ignore_missing):
 
 
 def _substitute_item(substitutions, item, path, jinja, ignore_missing):
+    if isinstance(item, ESPLiteralValue):
+        return None  # do not substitute inside literal blocks
     if isinstance(item, list):
         for i, it in enumerate(item):
             sub = _substitute_item(substitutions, it, path + [i], jinja, ignore_missing)