Merge pull request #13951 from esphome/bump-2026.2.0b1

2026.2.0b1

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.3.0-dev
+PROJECT_NUMBER         = 2026.2.0b1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/analyze_memory/const.py

@@ -256,7 +256,7 @@ SYMBOL_PATTERNS = {
     "ipv6_stack": ["nd6_", "ip6_", "mld6_", "icmp6_", "icmp6_input"],
     # Order matters! More specific categories must come before general ones.
     # mdns must come before bluetooth to avoid "_mdns_disable_pcb" matching "ble_" pattern
-    "mdns_lib": ["mdns", "packet$"],
+    "mdns_lib": ["mdns"],
     # memory_mgmt must come before wifi_stack to catch mmu_hal_* symbols
     "memory_mgmt": [
         "mem_",
@@ -794,6 +794,7 @@ SYMBOL_PATTERNS = {
         "s_dp",
         "s_ni",
         "s_reg_dump",
+        "packet$",
         "d_mult_table",
         "K",
         "fcstab",

esphome/components/mipi_spi/models/waveshare.py

@@ -1,17 +1,4 @@
-from esphome.components.mipi import (
-    ETMOD,
-    FRMCTR2,
-    GMCTRN1,
-    GMCTRP1,
-    IFCTR,
-    MODE_RGB,
-    PWCTR1,
-    PWCTR3,
-    PWCTR4,
-    PWCTR5,
-    PWSET,
-    DriverChip,
-)
+from esphome.components.mipi import DriverChip
 import esphome.config_validation as cv
 
 from .amoled import CO5300
@@ -142,16 +129,6 @@ DriverChip(
         ),
     ),
 )
-ST7789P = DriverChip(
-    "ST7789P",
-    # Max supported dimensions
-    width=240,
-    height=320,
-    # SPI: RGB layout
-    color_order=MODE_RGB,
-    invert_colors=True,
-    draw_rounding=1,
-)
 
 ILI9488_A.extend(
     "PICO-RESTOUCH-LCD-3.5",
@@ -185,61 +162,3 @@ AXS15231.extend(
     cs_pin=9,
     reset_pin=21,
 )
-
-# Waveshare 1.83-v2
-#
-# Do not use on 1.83-v1: Vendor warning on different chip!
-ST7789P.extend(
-    "WAVESHARE-1.83-V2",
-    # Panel size smaller than ST7789 max allowed
-    width=240,
-    height=284,
-    # Vendor specific init derived from vendor sample code
-    # "LCD_1.83_Code_Rev2/ESP32/LCD_1in83/LCD_Driver.cpp"
-    # Compatible MIT license, see esphome/LICENSE file.
-    initsequence=(
-        (FRMCTR2, 0x0C, 0x0C, 0x00, 0x33, 0x33),
-        (ETMOD, 0x35),
-        (0xBB, 0x19),
-        (PWCTR1, 0x2C),
-        (PWCTR3, 0x01),
-        (PWCTR4, 0x12),
-        (PWCTR5, 0x20),
-        (IFCTR, 0x0F),
-        (PWSET, 0xA4, 0xA1),
-        (
-            GMCTRP1,
-            0xD0,
-            0x04,
-            0x0D,
-            0x11,
-            0x13,
-            0x2B,
-            0x3F,
-            0x54,
-            0x4C,
-            0x18,
-            0x0D,
-            0x0B,
-            0x1F,
-            0x23,
-        ),
-        (
-            GMCTRN1,
-            0xD0,
-            0x04,
-            0x0C,
-            0x11,
-            0x13,
-            0x2C,
-            0x3F,
-            0x44,
-            0x51,
-            0x2F,
-            0x1F,
-            0x1F,
-            0x20,
-            0x23,
-        ),
-    ),
-)

esphome/components/uart/uart_component_esp_idf.cpp

@@ -90,6 +90,7 @@ void IDFUARTComponent::setup() {
     return;
   }
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
+  this->lock_ = xSemaphoreCreateMutex();
 
 #if (SOC_UART_LP_NUM >= 1)
   size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
@@ -101,7 +102,11 @@ void IDFUARTComponent::setup() {
     this->rx_buffer_size_ = fifo_len * 2;
   }
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
+
   this->load_settings(false);
+
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::load_settings(bool dump_config) {
@@ -121,20 +126,13 @@ void IDFUARTComponent::load_settings(bool dump_config) {
       return;
     }
   }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
-  constexpr int event_queue_size = 20;
-  QueueHandle_t *event_queue_ptr = &this->uart_event_queue_;
-#else
-  constexpr int event_queue_size = 0;
-  QueueHandle_t *event_queue_ptr = nullptr;
-#endif
   err = uart_driver_install(this->uart_num_,        // UART number
                             this->rx_buffer_size_,  // RX ring buffer size
-                            0,  // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
-                                // block task until all data has been sent out
-                            event_queue_size,  // event queue size/depth
-                            event_queue_ptr,   // event queue
-                            0                  // Flags used to allocate the interrupt
+                            0,   // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
+                                 // block task until all data has been sent out
+                            20,  // event queue size/depth
+                            &this->uart_event_queue_,  // event queue
+                            0                          // Flags used to allocate the interrupt
   );
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
@@ -284,7 +282,9 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 }
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  xSemaphoreGive(this->lock_);
   if (write_len != (int32_t) len) {
     ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
     this->mark_failed();
@@ -299,6 +299,7 @@ void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
 bool IDFUARTComponent::peek_byte(uint8_t *data) {
   if (!this->check_read_timeout_())
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     *data = this->peek_byte_;
   } else {
@@ -310,6 +311,7 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
       this->peek_byte_ = *data;
     }
   }
+  xSemaphoreGive(this->lock_);
   return true;
 }
 
@@ -318,6 +320,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     length_to_read--;
     *data = this->peek_byte_;
@@ -326,6 +329,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   }
   if (length_to_read > 0)
     read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+  xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
@@ -338,7 +342,9 @@ size_t IDFUARTComponent::available() {
   size_t available = 0;
   esp_err_t err;
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   err = uart_get_buffered_data_len(this->uart_num_, &available);
+  xSemaphoreGive(this->lock_);
 
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
@@ -352,7 +358,9 @@ size_t IDFUARTComponent::available() {
 
 void IDFUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   uart_wait_tx_done(this->uart_num_, portMAX_DELAY);
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::check_logger_conflict() {}
@@ -376,13 +384,6 @@ void IDFUARTComponent::start_rx_event_task_() {
   ESP_LOGV(TAG, "RX event task started");
 }
 
-// FreeRTOS task that relays UART ISR events to the main loop.
-// This task exists because wake_loop_threadsafe() is not ISR-safe (it uses a
-// UDP loopback socket), so we need a task as an ISR-to-main-loop trampoline.
-// IMPORTANT: This task must NOT call any UART wrapper methods (read_array,
-// write_array, peek_byte, etc.) or touch has_peek_/peek_byte_ — all reading
-// is done by the main loop. This task only reads from the event queue and
-// calls App.wake_loop_threadsafe().
 void IDFUARTComponent::rx_event_task_func(void *param) {
   auto *self = static_cast<IDFUARTComponent *>(param);
   uart_event_t event;
@@ -404,14 +405,8 @@ void IDFUARTComponent::rx_event_task_func(void *param) {
 
         case UART_FIFO_OVF:
         case UART_BUFFER_FULL:
-          // Don't call uart_flush_input() here — this task does not own the read side.
-          // ESP-IDF examples flush on overflow because the same task handles both events
-          // and reads, so flush and read are serialized. Here, reads happen on the main
-          // loop, so flushing from this task races with read_array() and can destroy data
-          // mid-read. The driver self-heals without an explicit flush: uart_read_bytes()
-          // calls uart_check_buf_full() after each chunk, which moves stashed FIFO bytes
-          // into the ring buffer and re-enables RX interrupts once space is freed.
-          ESP_LOGW(TAG, "FIFO overflow or ring buffer full");
+          ESP_LOGW(TAG, "FIFO overflow or ring buffer full - clearing");
+          uart_flush_input(self->uart_num_);
 #if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
           App.wake_loop_threadsafe();
 #endif

esphome/components/uart/uart_component_esp_idf.h

@@ -8,13 +8,6 @@
 
 namespace esphome::uart {
 
-/// ESP-IDF UART driver wrapper.
-///
-/// Thread safety: All public methods must only be called from the main loop.
-/// The ESP-IDF UART driver API does not guarantee thread safety, and ESPHome's
-/// peek byte state (has_peek_/peek_byte_) is not synchronized. The rx_event_task
-/// (when enabled) must not call any of these methods — it communicates with the
-/// main loop exclusively via App.wake_loop_threadsafe().
 class IDFUARTComponent : public UARTComponent, public Component {
  public:
   void setup() override;
@@ -33,9 +26,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   void flush() override;
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
   QueueHandle_t *get_uart_event_queue() { return &this->uart_event_queue_; }
-#endif
 
   /**
    * Load the UART with the current settings.
@@ -55,20 +46,18 @@ class IDFUARTComponent : public UARTComponent, public Component {
  protected:
   void check_logger_conflict() override;
   uart_port_t uart_num_;
+  QueueHandle_t uart_event_queue_;
   uart_config_t get_config_();
+  SemaphoreHandle_t lock_;
 
   bool has_peek_{false};
   uint8_t peek_byte_;
 
 #ifdef USE_UART_WAKE_LOOP_ON_RX
-  // RX notification support — runs on a separate FreeRTOS task.
-  // IMPORTANT: rx_event_task_func must NOT call any UART wrapper methods (read_array,
-  // write_array, etc.) or touch has_peek_/peek_byte_. It must only read from the
-  // event queue and call App.wake_loop_threadsafe().
+  // RX notification support
   void start_rx_event_task_();
   static void rx_event_task_func(void *param);
 
-  QueueHandle_t uart_event_queue_;
   TaskHandle_t rx_event_task_handle_{nullptr};
 #endif  // USE_UART_WAKE_LOOP_ON_RX
 };

esphome/components/usb_host/usb_host.h

@@ -148,7 +148,6 @@ class USBClient : public Component {
   EventPool<UsbEvent, USB_EVENT_QUEUE_SIZE> event_pool;
 
  protected:
-  void handle_open_state_();
   TransferRequest *get_trq_();  // Lock-free allocation using atomic bitmask (multi-consumer safe)
   virtual void disconnect();
   virtual void on_connected() {}

esphome/components/usb_host/usb_host_client.cpp

@@ -9,7 +9,6 @@
 #include <cinttypes>
 #include <cstring>
 #include <atomic>
-#include <span>
 namespace esphome {
 namespace usb_host {
 
@@ -143,23 +142,18 @@ static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc
   } while (next_desc != NULL);
 }
 #endif
-// USB string descriptors: bLength (uint8_t, max 255) includes the 2-byte header (bLength and bDescriptorType).
-// Character count = (bLength - 2) / 2, max 126 chars + null terminator.
-static constexpr size_t DESC_STRING_BUF_SIZE = 128;
-
-static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
-  if (desc == nullptr || desc->bLength < 2)
+static std::string get_descriptor_string(const usb_str_desc_t *desc) {
+  char buffer[256];
+  if (desc == nullptr)
     return "(unspecified)";
-  int char_count = (desc->bLength - 2) / 2;
-  char *p = buffer.data();
-  char *end = p + buffer.size() - 1;
-  for (int i = 0; i != char_count && p < end; i++) {
+  char *p = buffer;
+  for (int i = 0; i != desc->bLength / 2; i++) {
     auto c = desc->wData[i];
     if (c < 0x100)
       *p++ = static_cast<char>(c);
   }
   *p = '\0';
-  return buffer.data();
+  return {buffer};
 }
 
 // CALLBACK CONTEXT: USB task (called from usb_host_client_handle_events in USB task)
@@ -265,63 +259,60 @@ void USBClient::loop() {
     ESP_LOGW(TAG, "Dropped %u USB events due to queue overflow", dropped);
   }
 
-  if (this->state_ == USB_CLIENT_OPEN) {
-    this->handle_open_state_();
-  }
-}
-
-void USBClient::handle_open_state_() {
-  int err;
-  ESP_LOGD(TAG, "Open device %d", this->device_addr_);
-  err = usb_host_device_open(this->handle_, this->device_addr_, &this->device_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device open failed: %s", esp_err_to_name(err));
-    this->state_ = USB_CLIENT_INIT;
-    return;
-  }
-  ESP_LOGD(TAG, "Get descriptor device %d", this->device_addr_);
-  const usb_device_desc_t *desc;
-  err = usb_host_get_device_descriptor(this->device_handle_, &desc);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device get_desc failed: %s", esp_err_to_name(err));
-    this->disconnect();
-    return;
-  }
-  ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
-  if (desc->idVendor != this->vid_ || desc->idProduct != this->pid_) {
-    if (this->vid_ != 0 || this->pid_ != 0) {
-      ESP_LOGD(TAG, "Not our device, closing");
-      this->disconnect();
-      return;
-    }
-  }
-  usb_device_info_t dev_info;
-  err = usb_host_device_info(this->device_handle_, &dev_info);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device info failed: %s", esp_err_to_name(err));
-    this->disconnect();
-    return;
-  }
-  this->state_ = USB_CLIENT_CONNECTED;
-  char buf_manuf[DESC_STRING_BUF_SIZE];
-  char buf_product[DESC_STRING_BUF_SIZE];
-  char buf_serial[DESC_STRING_BUF_SIZE];
-  ESP_LOGD(TAG, "Device connected: Manuf: %s; Prod: %s; Serial: %s",
-           get_descriptor_string(dev_info.str_desc_manufacturer, buf_manuf),
-           get_descriptor_string(dev_info.str_desc_product, buf_product),
-           get_descriptor_string(dev_info.str_desc_serial_num, buf_serial));
+  switch (this->state_) {
+    case USB_CLIENT_OPEN: {
+      int err;
+      ESP_LOGD(TAG, "Open device %d", this->device_addr_);
+      err = usb_host_device_open(this->handle_, this->device_addr_, &this->device_handle_);
+      if (err != ESP_OK) {
+        ESP_LOGW(TAG, "Device open failed: %s", esp_err_to_name(err));
+        this->state_ = USB_CLIENT_INIT;
+        break;
+      }
+      ESP_LOGD(TAG, "Get descriptor device %d", this->device_addr_);
+      const usb_device_desc_t *desc;
+      err = usb_host_get_device_descriptor(this->device_handle_, &desc);
+      if (err != ESP_OK) {
+        ESP_LOGW(TAG, "Device get_desc failed: %s", esp_err_to_name(err));
+        this->disconnect();
+      } else {
+        ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
+        if (desc->idVendor == this->vid_ && desc->idProduct == this->pid_ || this->vid_ == 0 && this->pid_ == 0) {
+          usb_device_info_t dev_info;
+          err = usb_host_device_info(this->device_handle_, &dev_info);
+          if (err != ESP_OK) {
+            ESP_LOGW(TAG, "Device info failed: %s", esp_err_to_name(err));
+            this->disconnect();
+            break;
+          }
+          this->state_ = USB_CLIENT_CONNECTED;
+          ESP_LOGD(TAG, "Device connected: Manuf: %s; Prod: %s; Serial: %s",
+                   get_descriptor_string(dev_info.str_desc_manufacturer).c_str(),
+                   get_descriptor_string(dev_info.str_desc_product).c_str(),
+                   get_descriptor_string(dev_info.str_desc_serial_num).c_str());
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  const usb_device_desc_t *device_desc;
-  err = usb_host_get_device_descriptor(this->device_handle_, &device_desc);
-  if (err == ESP_OK)
-    usb_client_print_device_descriptor(device_desc);
-  const usb_config_desc_t *config_desc;
-  err = usb_host_get_active_config_descriptor(this->device_handle_, &config_desc);
-  if (err == ESP_OK)
-    usb_client_print_config_descriptor(config_desc, nullptr);
+          const usb_device_desc_t *device_desc;
+          err = usb_host_get_device_descriptor(this->device_handle_, &device_desc);
+          if (err == ESP_OK)
+            usb_client_print_device_descriptor(device_desc);
+          const usb_config_desc_t *config_desc;
+          err = usb_host_get_active_config_descriptor(this->device_handle_, &config_desc);
+          if (err == ESP_OK)
+            usb_client_print_config_descriptor(config_desc, nullptr);
 #endif
-  this->on_connected();
+          this->on_connected();
+        } else {
+          ESP_LOGD(TAG, "Not our device, closing");
+          this->disconnect();
+        }
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
 }
 
 void USBClient::on_opened(uint8_t addr) {

esphome/components/web_server/web_server.cpp

@@ -557,9 +557,7 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
       root[ESPHOME_F("device")] = device_name;
     }
 #endif
-#ifdef USE_ENTITY_ICON
     root[ESPHOME_F("icon")] = obj->get_icon_ref();
-#endif
     root[ESPHOME_F("entity_category")] = obj->get_entity_category();
     bool is_disabled = obj->is_disabled_by_default();
     if (is_disabled)

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.3.0-dev"
+__version__ = "2026.2.0b1"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

script/build_language_schema.py

@@ -369,7 +369,7 @@ def get_logger_tags():
         "api.service",
     ]
     for file in CORE_COMPONENTS_PATH.rglob("*.cpp"):
-        data = file.read_text(encoding="utf-8")
+        data = file.read_text()
         match = pattern.search(data)
         if match:
             tags.append(match.group(1))

tests/components/mipi_spi/common.yaml

@@ -3,15 +3,9 @@ display:
     spi_16: true
     pixel_mode: 18bit
     model: ili9488
-    dc_pin:
-      allow_other_uses: true
-      number: ${dc_pin}
-    cs_pin:
-      allow_other_uses: true
-      number: ${cs_pin}
-    reset_pin:
-      allow_other_uses: true
-      number: ${reset_pin}
+    dc_pin: ${dc_pin}
+    cs_pin: ${cs_pin}
+    reset_pin: ${reset_pin}
     data_rate: 20MHz
     invert_colors: true
     show_test_card: true
@@ -30,15 +24,3 @@ display:
       height: 200
     enable_pin: ${enable_pin}
     bus_mode: single
-
-  - platform: mipi_spi
-    model: WAVESHARE-1.83-V2
-    dc_pin:
-      allow_other_uses: true
-      number: ${dc_pin}
-    cs_pin:
-      allow_other_uses: true
-      number: ${cs_pin}
-    reset_pin:
-      allow_other_uses: true
-      number: ${reset_pin}