esphome 2025.6.3__py3-none-any.whl → 2025.7.0b2__py3-none-any.whl

esphome/components/time/__init__.py

@@ -268,7 +268,19 @@ def validate_tz(value: str) -> str:
 
 TIME_SCHEMA = cv.Schema(
     {
-        cv.Optional(CONF_TIMEZONE, default=detect_tz): validate_tz,
+        cv.SplitDefault(
+            CONF_TIMEZONE,
+            esp8266=detect_tz,
+            esp32=detect_tz,
+            rp2040=detect_tz,
+            bk72xx=detect_tz,
+            rtl87xx=detect_tz,
+            ln882x=detect_tz,
+            host=detect_tz,
+        ): cv.All(
+            cv.only_with_framework(["arduino", "esp-idf", "host"]),
+            validate_tz,
+        ),
         cv.Optional(CONF_ON_TIME): automation.validate_automation(
             {
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CronTrigger),
@@ -293,7 +305,9 @@ TIME_SCHEMA = cv.Schema(
 
 
 async def setup_time_core_(time_var, config):
-    cg.add(time_var.set_timezone(config[CONF_TIMEZONE]))
+    if timezone := config.get(CONF_TIMEZONE):
+        cg.add(time_var.set_timezone(timezone))
+        cg.add_define("USE_TIME_TIMEZONE")
 
     for conf in config.get(CONF_ON_TIME, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], time_var)

esphome/components/time/real_time_clock.cpp

@@ -35,8 +35,10 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
+#ifdef USE_TIME_TIMEZONE
   // Move timezone back to local timezone.
   this->apply_timezone_();
+#endif
 
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
@@ -49,10 +51,12 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
   this->time_sync_callback_.call();
 }
 
+#ifdef USE_TIME_TIMEZONE
 void RealTimeClock::apply_timezone_() {
   setenv("TZ", this->timezone_.c_str(), 1);
   tzset();
 }
+#endif
 
 }  // namespace time
 }  // namespace esphome

esphome/components/time/real_time_clock.h

@@ -20,6 +20,7 @@ class RealTimeClock : public PollingComponent {
  public:
   explicit RealTimeClock();
 
+#ifdef USE_TIME_TIMEZONE
   /// Set the time zone.
   void set_timezone(const std::string &tz) {
     this->timezone_ = tz;
@@ -28,6 +29,7 @@ class RealTimeClock : public PollingComponent {
 
   /// Get the time zone currently in use.
   std::string get_timezone() { return this->timezone_; }
+#endif
 
   /// Get the time in the currently defined timezone.
   ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }
@@ -38,7 +40,7 @@ class RealTimeClock : public PollingComponent {
   /// Get the current time as the UTC epoch since January 1st 1970.
   time_t timestamp_now() { return ::time(nullptr); }
 
-  void add_on_time_sync_callback(std::function<void()> callback) {
+  void add_on_time_sync_callback(std::function<void()> &&callback) {
     this->time_sync_callback_.add(std::move(callback));
   };
 
@@ -46,8 +48,10 @@ class RealTimeClock : public PollingComponent {
   /// Report a unix epoch as current time.
   void synchronize_epoch_(uint32_t epoch);
 
+#ifdef USE_TIME_TIMEZONE
   std::string timezone_{};
   void apply_timezone_();
+#endif
 
   CallbackManager<void()> time_sync_callback_;
 };

esphome/components/tlc5971/tlc5971.cpp

@@ -24,8 +24,10 @@ void TLC5971::dump_config() {
 }
 
 void TLC5971::loop() {
-  if (!this->update_)
+  if (!this->update_) {
+    this->disable_loop();
     return;
+  }
 
   uint32_t command;
 
@@ -93,6 +95,7 @@ void TLC5971::set_channel_value(uint16_t channel, uint16_t value) {
     return;
   if (this->pwm_amounts_[channel] != value) {
     this->update_ = true;
+    this->enable_loop();
   }
   this->pwm_amounts_[channel] = value;
 }

esphome/components/tmp1075/tmp1075.h

@@ -58,8 +58,6 @@ class TMP1075Sensor : public PollingComponent, public sensor::Sensor, public i2c
   void setup() override;
   void update() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void dump_config() override;
 
   // Call write_config() after calling any of these to send the new config to

esphome/components/tof10120/tof10120_sensor.h

@@ -12,7 +12,6 @@ class TOF10120Sensor : public sensor::Sensor, public PollingComponent, public i2
   void setup() override;
 
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void update() override;
 };
 }  // namespace tof10120

esphome/components/tormatic/tormatic_cover.h

@@ -16,7 +16,6 @@ class Tormatic : public cover::Cover, public uart::UARTDevice, public PollingCom
   void loop() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; };
 
   void set_open_duration(uint32_t duration) { this->open_duration_ = duration; }
   void set_close_duration(uint32_t duration) { this->close_duration_ = duration; }

esphome/components/total_daily_energy/total_daily_energy.h

@@ -23,7 +23,6 @@ class TotalDailyEnergy : public sensor::Sensor, public Component {
   void set_method(TotalDailyEnergyMethod method) { method_ = method; }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void loop() override;
 
   void publish_state_and_save(float state);

esphome/components/tsl2591/tsl2591.cpp

@@ -232,7 +232,7 @@ void TSL2591Component::set_integration_time_and_gain(TSL2591IntegrationTime inte
   this->integration_time_ = integration_time;
   this->gain_ = gain;
   if (!this->write_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_CONTROL,
-                        this->integration_time_ | this->gain_)) {  // NOLINT
+                        static_cast<uint8_t>(this->integration_time_) | static_cast<uint8_t>(this->gain_))) {
     ESP_LOGE(TAG, "I2C write failed");
   }
   // The ADC values can be confused if gain or integration time are changed in the middle of a cycle.

esphome/components/ttp229_bsf/ttp229_bsf.h

@@ -25,7 +25,6 @@ class TTP229BSFComponent : public Component {
   void register_channel(TTP229BSFChannel *channel) { this->channels_.push_back(channel); }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void loop() override {
     // check datavalid if sdo is high
     if (!this->sdo_pin_->digital_read()) {

esphome/components/ttp229_lsf/ttp229_lsf.h

@@ -23,7 +23,6 @@ class TTP229LSFComponent : public Component, public i2c::I2CDevice {
   void register_channel(TTP229Channel *channel) { this->channels_.push_back(channel); }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void loop() override;
 
  protected:

esphome/components/tx20/tx20.cpp

@@ -152,7 +152,7 @@ void IRAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) {
     }
     arg->buffer[arg->buffer_index] = 1;
     arg->start_time = now;
-    arg->buffer_index++;
+    arg->buffer_index++;  // NOLINT(clang-diagnostic-deprecated-volatile)
     return;
   }
   const uint32_t delay = now - arg->start_time;
@@ -183,7 +183,7 @@ void IRAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) {
   }
   arg->spent_time += delay;
   arg->start_time = now;
-  arg->buffer_index++;
+  arg->buffer_index++;  // NOLINT(clang-diagnostic-deprecated-volatile)
 }
 void IRAM_ATTR Tx20ComponentStore::reset() {
   tx20_available = false;

esphome/components/uart/__init__.py

@@ -2,6 +2,7 @@ import re
 
 from esphome import automation, pins
 import esphome.codegen as cg
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_AFTER,
@@ -27,6 +28,7 @@ from esphome.const import (
     CONF_TX_PIN,
     CONF_UART_ID,
     PLATFORM_HOST,
+    PlatformFramework,
 )
 from esphome.core import CORE
 import esphome.final_validate as fv
@@ -438,3 +440,19 @@ async def uart_write_to_code(config, action_id, template_arg, args):
     else:
         cg.add(var.set_data_static(data))
     return var
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "uart_component_esp32_arduino.cpp": {PlatformFramework.ESP32_ARDUINO},
+        "uart_component_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
+        "uart_component_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "uart_component_host.cpp": {PlatformFramework.HOST_NATIVE},
+        "uart_component_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
+        "uart_component_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+    }
+)

esphome/components/uart/uart_component_esp_idf.cpp

@@ -48,11 +48,7 @@ uart_config_t IDFUARTComponent::get_config_() {
   uart_config.parity = parity;
   uart_config.stop_bits = this->stop_bits_ == 1 ? UART_STOP_BITS_1 : UART_STOP_BITS_2;
   uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
   uart_config.source_clk = UART_SCLK_DEFAULT;
-#else
-  uart_config.source_clk = UART_SCLK_APB;
-#endif
   uart_config.rx_flow_ctrl_thresh = 122;
 
   return uart_config;

esphome/components/update/__init__.py

@@ -15,8 +15,8 @@ from esphome.const import (
     ENTITY_CATEGORY_CONFIG,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
-from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@jesserockz"]
 IS_PLATFORM_COMPONENT = True
@@ -58,6 +58,9 @@ _UPDATE_SCHEMA = (
 )
 
 
+_UPDATE_SCHEMA.add_extra(entity_duplicate_validator("update"))
+
+
 def update_schema(
     class_: MockObjClass = cv.UNDEFINED,
     *,
@@ -87,7 +90,7 @@ UPDATE_SCHEMA.add_extra(cv.deprecated_schema_constant("update"))
 
 
 async def setup_update_core_(var, config):
-    await setup_entity(var, config)
+    await setup_entity(var, config, "update")
 
     if device_class_config := config.get(CONF_DEVICE_CLASS):
         cg.add(var.set_device_class(device_class_config))

esphome/components/update/update_entity.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <memory>
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
@@ -38,12 +39,19 @@ class UpdateEntity : public EntityBase, public EntityBase_DeviceClass {
   const UpdateState &state = state_;
 
   void add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
+  Trigger<const UpdateInfo &> *get_update_available_trigger() {
+    if (!update_available_trigger_) {
+      update_available_trigger_ = std::make_unique<Trigger<const UpdateInfo &>>();
+    }
+    return update_available_trigger_.get();
+  }
 
  protected:
   UpdateState state_{UPDATE_STATE_UNKNOWN};
   UpdateInfo update_info_;
 
   CallbackManager<void()> state_callback_{};
+  std::unique_ptr<Trigger<const UpdateInfo &>> update_available_trigger_{nullptr};
 };
 
 }  // namespace update

esphome/components/usb_host/__init__.py

@@ -6,7 +6,7 @@ from esphome.components.esp32 import (
     only_on_variant,
 )
 import esphome.config_validation as cv
-from esphome.const import CONF_ID
+from esphome.const import CONF_DEVICES, CONF_ID
 from esphome.cpp_types import Component
 
 AUTO_LOAD = ["bytebuffer"]
@@ -16,9 +16,9 @@ usb_host_ns = cg.esphome_ns.namespace("usb_host")
 USBHost = usb_host_ns.class_("USBHost", Component)
 USBClient = usb_host_ns.class_("USBClient", Component)
 
-CONF_DEVICES = "devices"
 CONF_VID = "vid"
 CONF_PID = "pid"
+CONF_ENABLE_HUBS = "enable_hubs"
 
 
 def usb_device_schema(cls=USBClient, vid: int = None, pid: [int] = None) -> cv.Schema:
@@ -42,6 +42,7 @@ CONFIG_SCHEMA = cv.All(
     cv.COMPONENT_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(USBHost),
+            cv.Optional(CONF_ENABLE_HUBS, default=False): cv.boolean,
             cv.Optional(CONF_DEVICES): cv.ensure_list(usb_device_schema()),
         }
     ),
@@ -58,6 +59,8 @@ async def register_usb_client(config):
 
 async def to_code(config):
     add_idf_sdkconfig_option("CONFIG_USB_HOST_CONTROL_TRANSFER_MAX_SIZE", 1024)
+    if config.get(CONF_ENABLE_HUBS):
+        add_idf_sdkconfig_option("CONFIG_USB_HOST_HUBS_SUPPORTED", True)
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     for device in config.get(CONF_DEVICES) or ():

esphome/components/usb_host/usb_host_client.cpp

@@ -70,7 +70,7 @@ static void usbh_print_cfg_desc(const usb_config_desc_t *cfg_desc) {
   ESP_LOGV(TAG, "bMaxPower %dmA", cfg_desc->bMaxPower * 2);
 }
 
-void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
+static void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
   if (devc_desc == NULL) {
     return;
   }
@@ -92,8 +92,8 @@ void usb_client_print_device_descriptor(const usb_device_desc_t *devc_desc) {
   ESP_LOGV(TAG, "bNumConfigurations %d", devc_desc->bNumConfigurations);
 }
 
-void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
-                                        print_class_descriptor_cb class_specific_cb) {
+static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
+                                               print_class_descriptor_cb class_specific_cb) {
   if (cfg_desc == nullptr) {
     return;
   }
@@ -128,9 +128,9 @@ void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc,
 static std::string get_descriptor_string(const usb_str_desc_t *desc) {
   char buffer[256];
   if (desc == nullptr)
-    return "(unknown)";
+    return "(unspecified)";
   char *p = buffer;
-  for (size_t i = 0; i != desc->bLength / 2; i++) {
+  for (int i = 0; i != desc->bLength / 2; i++) {
     auto c = desc->wData[i];
     if (c < 0x100)
       *p++ = static_cast<char>(c);
@@ -169,7 +169,7 @@ void USBClient::setup() {
     this->mark_failed();
     return;
   }
-  for (auto trq : this->trq_pool_) {
+  for (auto *trq : this->trq_pool_) {
     usb_host_transfer_alloc(64, 0, &trq->transfer);
     trq->client = this;
   }
@@ -197,7 +197,8 @@ void USBClient::loop() {
         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;
-          if ((err = usb_host_device_info(this->device_handle_, &dev_info)) != ESP_OK) {
+          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;
@@ -336,7 +337,7 @@ static void transfer_callback(usb_transfer_t *xfer) {
  * @throws None.
  */
 void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, uint16_t length) {
-  auto trq = this->get_trq_();
+  auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
     return;
@@ -349,7 +350,6 @@ void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, u
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "Failed to submit transfer, address=%x, length=%d, err=%x", ep_address, length, err);
     this->release_trq(trq);
-    this->disconnect();
   }
 }
 
@@ -364,7 +364,7 @@ void USBClient::transfer_in(uint8_t ep_address, const transfer_cb_t &callback, u
  * @throws None.
  */
 void USBClient::transfer_out(uint8_t ep_address, const transfer_cb_t &callback, const uint8_t *data, uint16_t length) {
-  auto trq = this->get_trq_();
+  auto *trq = this->get_trq_();
   if (trq == nullptr) {
     ESP_LOGE(TAG, "Too many requests queued");
     return;

esphome/components/usb_uart/cp210x.cpp

@@ -43,7 +43,7 @@ static constexpr uint8_t SET_BAUDRATE = 0x1E;     // Set the baud rate.
 static constexpr uint8_t SET_CHARS = 0x19;        // Set special characters.
 static constexpr uint8_t VENDOR_SPECIFIC = 0xFF;  // Vendor specific command.
 
-std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors_(usb_device_handle_t dev_hdl) {
+std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors(usb_device_handle_t dev_hdl) {
   const usb_config_desc_t *config_desc;
   const usb_device_desc_t *device_desc;
   int conf_offset = 0, ep_offset;

esphome/components/usb_uart/usb_uart.cpp

@@ -18,52 +18,48 @@ namespace usb_uart {
  */
 static optional<CdcEps> get_cdc(const usb_config_desc_t *config_desc, uint8_t intf_idx) {
   int conf_offset, ep_offset;
-  const usb_ep_desc_t *notify_ep{}, *in_ep{}, *out_ep{};
-  uint8_t interface_number = 0;
-  // look for an interface with one interrupt endpoint (notify), and an interface with two bulk endpoints (data in/out)
+  // look for an interface with an interrupt endpoint (notify), and one with two bulk endpoints (data in/out)
+  CdcEps eps{};
+  eps.bulk_interface_number = 0xFF;
   for (;;) {
-    auto intf_desc = usb_parse_interface_descriptor(config_desc, intf_idx++, 0, &conf_offset);
+    const auto *intf_desc = usb_parse_interface_descriptor(config_desc, intf_idx++, 0, &conf_offset);
     if (!intf_desc) {
       ESP_LOGE(TAG, "usb_parse_interface_descriptor failed");
       return nullopt;
     }
-    if (intf_desc->bNumEndpoints == 1) {
+    ESP_LOGD(TAG, "intf_desc: bInterfaceClass=%02X, bInterfaceSubClass=%02X, bInterfaceProtocol=%02X, bNumEndpoints=%d",
+             intf_desc->bInterfaceClass, intf_desc->bInterfaceSubClass, intf_desc->bInterfaceProtocol,
+             intf_desc->bNumEndpoints);
+    for (uint8_t i = 0; i != intf_desc->bNumEndpoints; i++) {
       ep_offset = conf_offset;
-      notify_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
-      if (!notify_ep) {
-        ESP_LOGE(TAG, "notify_ep: usb_parse_endpoint_descriptor_by_index failed");
+      const auto *ep = usb_parse_endpoint_descriptor_by_index(intf_desc, i, config_desc->wTotalLength, &ep_offset);
+      if (!ep) {
+        ESP_LOGE(TAG, "Ran out of interfaces at %d before finding all endpoints", i);
         return nullopt;
       }
-      if (notify_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_INT)
-        notify_ep = nullptr;
-    } else if (USB_CLASS_CDC_DATA && intf_desc->bNumEndpoints == 2) {
-      interface_number = intf_desc->bInterfaceNumber;
-      ep_offset = conf_offset;
-      out_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
-      if (!out_ep) {
-        ESP_LOGE(TAG, "out_ep: usb_parse_endpoint_descriptor_by_index failed");
-        return nullopt;
-      }
-      if (out_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
-        out_ep = nullptr;
-      ep_offset = conf_offset;
-      in_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 1, config_desc->wTotalLength, &ep_offset);
-      if (!in_ep) {
-        ESP_LOGE(TAG, "in_ep: usb_parse_endpoint_descriptor_by_index failed");
-        return nullopt;
+      ESP_LOGD(TAG, "ep: bEndpointAddress=%02X, bmAttributes=%02X", ep->bEndpointAddress, ep->bmAttributes);
+      if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_INT) {
+        eps.notify_ep = ep;
+        eps.interrupt_interface_number = intf_desc->bInterfaceNumber;
+      } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && ep->bEndpointAddress & usb_host::USB_DIR_IN &&
+                 (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
+        eps.in_ep = ep;
+        eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+      } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && !(ep->bEndpointAddress & usb_host::USB_DIR_IN) &&
+                 (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
+        eps.out_ep = ep;
+        eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+      } else {
+        ESP_LOGE(TAG, "Unexpected endpoint attributes: %02X", ep->bmAttributes);
+        continue;
       }
-      if (in_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
-        in_ep = nullptr;
     }
-    if (in_ep != nullptr && out_ep != nullptr && notify_ep != nullptr)
-      break;
+    if (eps.in_ep != nullptr && eps.out_ep != nullptr && eps.notify_ep != nullptr)
+      return eps;
   }
-  if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN)
-    return CdcEps{notify_ep, in_ep, out_ep, interface_number};
-  return CdcEps{notify_ep, out_ep, in_ep, interface_number};
 }
 
-std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors_(usb_device_handle_t dev_hdl) {
+std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors(usb_device_handle_t dev_hdl) {
   const usb_config_desc_t *config_desc;
   const usb_device_desc_t *device_desc;
   int desc_offset = 0;
@@ -78,7 +74,7 @@ std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors_(usb_device_handle_t de
     ESP_LOGE(TAG, "get_active_config_descriptor failed");
     return {};
   }
-  if (device_desc->bDeviceClass == USB_CLASS_COMM) {
+  if (device_desc->bDeviceClass == USB_CLASS_COMM || device_desc->bDeviceClass == USB_CLASS_VENDOR_SPEC) {
     // single CDC-ACM device
     if (auto eps = get_cdc(config_desc, 0)) {
       ESP_LOGV(TAG, "Found CDC-ACM device");
@@ -194,7 +190,7 @@ void USBUartComponent::start_input(USBUartChannel *channel) {
   if (!channel->initialised_ || channel->input_started_ ||
       channel->input_buffer_.get_free_space() < channel->cdc_dev_.in_ep->wMaxPacketSize)
     return;
-  auto ep = channel->cdc_dev_.in_ep;
+  const auto *ep = channel->cdc_dev_.in_ep;
   auto callback = [this, channel](const usb_host::TransferStatus &status) {
     ESP_LOGV(TAG, "Transfer result: length: %u; status %X", status.data_len, status.error_code);
     if (!status.success) {
@@ -227,7 +223,7 @@ void USBUartComponent::start_output(USBUartChannel *channel) {
   if (channel->output_buffer_.is_empty()) {
     return;
   }
-  auto ep = channel->cdc_dev_.out_ep;
+  const auto *ep = channel->cdc_dev_.out_ep;
   auto callback = [this, channel](const usb_host::TransferStatus &status) {
     ESP_LOGV(TAG, "Output Transfer result: length: %u; status %X", status.data_len, status.error_code);
     channel->output_started_ = false;
@@ -259,15 +255,15 @@ static void fix_mps(const usb_ep_desc_t *ep) {
   }
 }
 void USBUartTypeCdcAcm::on_connected() {
-  auto cdc_devs = this->parse_descriptors_(this->device_handle_);
+  auto cdc_devs = this->parse_descriptors(this->device_handle_);
   if (cdc_devs.empty()) {
     this->status_set_error("No CDC-ACM device found");
     this->disconnect();
     return;
   }
   ESP_LOGD(TAG, "Found %zu CDC-ACM devices", cdc_devs.size());
-  auto i = 0;
-  for (auto channel : this->channels_) {
+  size_t i = 0;
+  for (auto *channel : this->channels_) {
     if (i == cdc_devs.size()) {
       ESP_LOGE(TAG, "No configuration found for channel %d", channel->index_);
       this->status_set_warning("No configuration found for channel");
@@ -277,10 +273,11 @@ void USBUartTypeCdcAcm::on_connected() {
     fix_mps(channel->cdc_dev_.in_ep);
     fix_mps(channel->cdc_dev_.out_ep);
     channel->initialised_ = true;
-    auto err = usb_host_interface_claim(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number, 0);
+    auto err =
+        usb_host_interface_claim(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number, 0);
     if (err != ESP_OK) {
       ESP_LOGE(TAG, "usb_host_interface_claim failed: %s, channel=%d, intf=%d", esp_err_to_name(err), channel->index_,
-               channel->cdc_dev_.interface_number);
+               channel->cdc_dev_.bulk_interface_number);
       this->status_set_error("usb_host_interface_claim failed");
       this->disconnect();
       return;
@@ -290,7 +287,7 @@ void USBUartTypeCdcAcm::on_connected() {
 }
 
 void USBUartTypeCdcAcm::on_disconnected() {
-  for (auto channel : this->channels_) {
+  for (auto *channel : this->channels_) {
     if (channel->cdc_dev_.in_ep != nullptr) {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
@@ -303,7 +300,7 @@ void USBUartTypeCdcAcm::on_disconnected() {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
     }
-    usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number);
+    usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number);
     channel->initialised_ = false;
     channel->input_started_ = false;
     channel->output_started_ = false;
@@ -314,7 +311,7 @@ void USBUartTypeCdcAcm::on_disconnected() {
 }
 
 void USBUartTypeCdcAcm::enable_channels() {
-  for (auto channel : this->channels_) {
+  for (auto *channel : this->channels_) {
     if (!channel->initialised_)
       continue;
     channel->input_started_ = false;

esphome/components/usb_uart/usb_uart.h

@@ -25,7 +25,8 @@ struct CdcEps {
   const usb_ep_desc_t *notify_ep;
   const usb_ep_desc_t *in_ep;
   const usb_ep_desc_t *out_ep;
-  uint8_t interface_number;
+  uint8_t bulk_interface_number;
+  uint8_t interrupt_interface_number;
 };
 
 enum UARTParityOptions {
@@ -123,7 +124,7 @@ class USBUartTypeCdcAcm : public USBUartComponent {
   USBUartTypeCdcAcm(uint16_t vid, uint16_t pid) : USBUartComponent(vid, pid) {}
 
  protected:
-  virtual std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl);
+  virtual std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl);
   void on_connected() override;
   virtual void enable_channels();
   void on_disconnected() override;
@@ -134,7 +135,7 @@ class USBUartTypeCP210X : public USBUartTypeCdcAcm {
   USBUartTypeCP210X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {}
 
  protected:
-  std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl) override;
+  std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl) override;
   void enable_channels() override;
 };
 class USBUartTypeCH34X : public USBUartTypeCdcAcm {

esphome/components/valve/__init__.py

@@ -22,8 +22,8 @@ from esphome.const import (
     DEVICE_CLASS_WATER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
-from esphome.cpp_helpers import setup_entity
 
 IS_PLATFORM_COMPONENT = True
 
@@ -103,6 +103,9 @@ _VALVE_SCHEMA = (
 )
 
 
+_VALVE_SCHEMA.add_extra(entity_duplicate_validator("valve"))
+
+
 def valve_schema(
     class_: MockObjClass = cv.UNDEFINED,
     *,
@@ -132,7 +135,7 @@ VALVE_SCHEMA.add_extra(cv.deprecated_schema_constant("valve"))
 
 
 async def _setup_valve_core(var, config):
-    await setup_entity(var, config)
+    await setup_entity(var, config, "valve")
 
     if device_class_config := config.get(CONF_DEVICE_CLASS):
         cg.add(var.set_device_class(device_class_config))

esphome/components/vbus/vbus.h

@@ -30,7 +30,6 @@ class VBus : public uart::UARTDevice, public Component {
  public:
   void dump_config() override;
   void loop() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void register_listener(VBusListener *listener) { this->listeners_.push_back(listener); }