esphome 2025.4.2__py3-none-any.whl → 2025.5.0b3__py3-none-any.whl

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -154,6 +154,21 @@ enum class ClientState {
   ESTABLISHED,
 };
 
+enum class ScannerState {
+  // Scanner is idle, init state, set from the main loop when processing STOPPED
+  IDLE,
+  // Scanner is starting, set from the main loop only
+  STARTING,
+  // Scanner is running, set from the ESP callback only
+  RUNNING,
+  // Scanner failed to start, set from the ESP callback only
+  FAILED,
+  // Scanner is stopping, set from the main loop only
+  STOPPING,
+  // Scanner is stopped, set from the ESP callback only
+  STOPPED,
+};
+
 enum class ConnectionType {
   // The default connection type, we hold all the services in ram
   // for the duration of the connection.
@@ -203,6 +218,7 @@ class ESP32BLETracker : public Component,
   void set_scan_interval(uint32_t scan_interval) { scan_interval_ = scan_interval; }
   void set_scan_window(uint32_t scan_window) { scan_window_ = scan_window; }
   void set_scan_active(bool scan_active) { scan_active_ = scan_active; }
+  bool get_scan_active() const { return scan_active_; }
   void set_scan_continuous(bool scan_continuous) { scan_continuous_ = scan_continuous; }
 
   /// Setup the FreeRTOS task and the Bluetooth stack.
@@ -226,6 +242,11 @@ class ESP32BLETracker : public Component,
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
   void ble_before_disabled_event_handler() override;
 
+  void add_scanner_state_callback(std::function<void(ScannerState)> &&callback) {
+    this->scanner_state_callbacks_.add(std::move(callback));
+  }
+  ScannerState get_scanner_state() const { return this->scanner_state_; }
+
  protected:
   void stop_scan_();
   /// Start a single scan by setting up the parameters and doing some esp-idf calls.
@@ -240,6 +261,8 @@ class ESP32BLETracker : public Component,
   void gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param);
   /// Called when a `ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT` event is received.
   void gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param);
+  /// Called to set the scanner state. Will also call callbacks to let listeners know when state is changed.
+  void set_scanner_state_(ScannerState state);
 
   int app_id_{0};
 
@@ -257,17 +280,17 @@ class ESP32BLETracker : public Component,
   uint8_t scan_start_fail_count_{0};
   bool scan_continuous_;
   bool scan_active_;
-  bool scanner_idle_{true};
+  ScannerState scanner_state_{ScannerState::IDLE};
+  CallbackManager<void(ScannerState)> scanner_state_callbacks_;
   bool ble_was_disabled_{true};
   bool raw_advertisements_{false};
   bool parse_advertisements_{false};
   SemaphoreHandle_t scan_result_lock_;
-  SemaphoreHandle_t scan_end_lock_;
   size_t scan_result_index_{0};
 #ifdef USE_PSRAM
   const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 32;
 #else
-  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 16;
+  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 20;
 #endif  // USE_PSRAM
   esp_ble_gap_cb_param_t::ble_scan_result_evt_param *scan_result_buffer_;
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
@@ -276,6 +299,9 @@ class ESP32BLETracker : public Component,
   int discovered_{0};
   int searching_{0};
   int disconnecting_{0};
+#ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
+  bool coex_prefer_ble_{false};
+#endif
 };
 
 // NOLINTNEXTLINE

esphome/components/esp32_camera/esp32_camera.cpp

@@ -3,6 +3,7 @@
 #include "esp32_camera.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/application.h"
 
 #include <freertos/task.h>
 
@@ -162,7 +163,7 @@ void ESP32Camera::loop() {
   }
 
   // request idle image every idle_update_interval
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   if (this->idle_update_interval_ != 0 && now - this->last_idle_request_ > this->idle_update_interval_) {
     this->last_idle_request_ = now;
     this->request_image(IDLE);

esphome/components/esp32_camera/esp32_camera.h

@@ -106,7 +106,7 @@ class CameraImageReader {
 };
 
 /* ---------------- ESP32Camera class ---------------- */
-class ESP32Camera : public Component, public EntityBase {
+class ESP32Camera : public EntityBase, public Component {
  public:
   ESP32Camera();
 

esphome/components/esp32_can/esp32_can.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "esp32_can";
 static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config) {
   switch (bitrate) {
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32C3) || \
-    defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H6)
+    defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
     case canbus::CAN_1KBPS:
       *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_1KBITS();
       return true;

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -92,7 +92,7 @@ void ESP32ImprovComponent::loop() {
 
   if (!this->incoming_data_.empty())
     this->process_incoming_data_();
-  uint32_t now = millis();
+  uint32_t now = App.get_loop_component_start_time();
 
   switch (this->state_) {
     case improv::STATE_STOPPED:

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -58,7 +58,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
   channel.flags.io_loop_back = 0;
   channel.flags.io_od_mode = 0;
   channel.flags.invert_out = 0;
-  channel.flags.with_dma = 0;
+  channel.flags.with_dma = this->use_dma_;
   channel.intr_priority = 0;
   if (rmt_new_tx_channel(&channel, &this->channel_) != ESP_OK) {
     ESP_LOGE(TAG, "Channel creation failed");

esphome/components/esp32_rmt_led_strip/led_strip.h

@@ -51,6 +51,7 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
   void set_num_leds(uint16_t num_leds) { this->num_leds_ = num_leds; }
   void set_is_rgbw(bool is_rgbw) { this->is_rgbw_ = is_rgbw; }
   void set_is_wrgb(bool is_wrgb) { this->is_wrgb_ = is_wrgb; }
+  void set_use_dma(bool use_dma) { this->use_dma_ = use_dma; }
   void set_use_psram(bool use_psram) { this->use_psram_ = use_psram; }
 
   /// Set a maximum refresh rate in µs as some lights do not like being updated too often.
@@ -85,7 +86,7 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
   rmt_encoder_handle_t encoder_{nullptr};
   rmt_symbol_word_t *rmt_buf_{nullptr};
   rmt_symbol_word_t bit0_, bit1_, reset_;
-  uint32_t rmt_symbols_;
+  uint32_t rmt_symbols_{48};
 #else
   rmt_item32_t *rmt_buf_{nullptr};
   rmt_item32_t bit0_, bit1_, reset_;
@@ -94,11 +95,12 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
 
   uint8_t pin_;
   uint16_t num_leds_;
-  bool is_rgbw_;
-  bool is_wrgb_;
-  bool use_psram_;
+  bool is_rgbw_{false};
+  bool is_wrgb_{false};
+  bool use_dma_{false};
+  bool use_psram_{false};
 
-  RGBOrder rgb_order_;
+  RGBOrder rgb_order_{ORDER_RGB};
 
   uint32_t last_refresh_{0};
   optional<uint32_t> max_refresh_rate_{};

esphome/components/esp32_rmt_led_strip/light.py

@@ -3,7 +3,7 @@ import logging
 
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32_rmt, light
+from esphome.components import esp32, esp32_rmt, light
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHIPSET,
@@ -15,6 +15,7 @@ from esphome.const import (
     CONF_RGB_ORDER,
     CONF_RMT_CHANNEL,
     CONF_RMT_SYMBOLS,
+    CONF_USE_DMA,
 )
 from esphome.core import CORE
 
@@ -138,6 +139,11 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
             cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
             cv.Optional(CONF_IS_WRGB, default=False): cv.boolean,
+            cv.Optional(CONF_USE_DMA): cv.All(
+                esp32.only_on_variant(supported=[esp32.const.VARIANT_ESP32S3]),
+                cv.only_with_esp_idf,
+                cv.boolean,
+            ),
             cv.Optional(CONF_USE_PSRAM, default=True): cv.boolean,
             cv.Inclusive(
                 CONF_BIT0_HIGH,
@@ -211,6 +217,8 @@ async def to_code(config):
 
     if esp32_rmt.use_new_rmt_driver():
         cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
+        if CONF_USE_DMA in config:
+            cg.add(var.set_use_dma(config[CONF_USE_DMA]))
     else:
         rmt_channel_t = cg.global_ns.enum("rmt_channel_t")
         cg.add(

esphome/components/esp32_touch/esp32_touch.cpp

@@ -288,7 +288,7 @@ uint32_t ESP32TouchComponent::component_touch_pad_read(touch_pad_t tp) {
 }
 
 void ESP32TouchComponent::loop() {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   bool should_print = this->setup_mode_ && now - this->setup_mode_last_log_print_ > 250;
   for (auto *child : this->children_) {
     child->value_ = this->component_touch_pad_read(child->get_touch_pad());

esphome/components/esp8266/gpio.cpp

@@ -8,7 +8,7 @@ namespace esp8266 {
 
 static const char *const TAG = "esp8266";
 
-static int IRAM_ATTR flags_to_mode(gpio::Flags flags, uint8_t pin) {
+static int flags_to_mode(gpio::Flags flags, uint8_t pin) {
   if (flags == gpio::FLAG_INPUT) {  // NOLINT(bugprone-branch-clone)
     return INPUT;
   } else if (flags == gpio::FLAG_OUTPUT) {
@@ -34,12 +34,36 @@ static int IRAM_ATTR flags_to_mode(gpio::Flags flags, uint8_t pin) {
 struct ISRPinArg {
   uint8_t pin;
   bool inverted;
+  volatile uint32_t *in_reg;
+  volatile uint32_t *out_set_reg;
+  volatile uint32_t *out_clr_reg;
+  volatile uint32_t *mode_set_reg;
+  volatile uint32_t *mode_clr_reg;
+  volatile uint32_t *func_reg;
+  uint32_t mask;
 };
 
 ISRInternalGPIOPin ESP8266GPIOPin::to_isr() const {
   auto *arg = new ISRPinArg{};  // NOLINT(cppcoreguidelines-owning-memory)
-  arg->pin = pin_;
-  arg->inverted = inverted_;
+  arg->pin = this->pin_;
+  arg->inverted = this->inverted_;
+  if (this->pin_ < 16) {
+    arg->in_reg = &GPI;
+    arg->out_set_reg = &GPOS;
+    arg->out_clr_reg = &GPOC;
+    arg->mode_set_reg = &GPES;
+    arg->mode_clr_reg = &GPEC;
+    arg->func_reg = &GPF(this->pin_);
+    arg->mask = 1 << this->pin_;
+  } else {
+    arg->in_reg = &GP16I;
+    arg->out_set_reg = &GP16O;
+    arg->out_clr_reg = nullptr;
+    arg->mode_set_reg = &GP16E;
+    arg->mode_clr_reg = nullptr;
+    arg->func_reg = &GPF16;
+    arg->mask = 1;
+  }
   return ISRInternalGPIOPin((void *) arg);
 }
 
@@ -88,20 +112,57 @@ void ESP8266GPIOPin::detach_interrupt() const { detachInterrupt(pin_); }
 using namespace esp8266;
 
 bool IRAM_ATTR ISRInternalGPIOPin::digital_read() {
-  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  return bool(digitalRead(arg->pin)) != arg->inverted;  // NOLINT
+  auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
+  return bool(*arg->in_reg & arg->mask) != arg->inverted;
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::digital_write(bool value) {
   auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  digitalWrite(arg->pin, value != arg->inverted ? 1 : 0);  // NOLINT
+  if (arg->pin < 16) {
+    if (value != arg->inverted) {
+      *arg->out_set_reg = arg->mask;
+    } else {
+      *arg->out_clr_reg = arg->mask;
+    }
+  } else {
+    if (value != arg->inverted) {
+      *arg->out_set_reg |= 1;
+    } else {
+      *arg->out_set_reg &= ~1;
+    }
+  }
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::clear_interrupt() {
   auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
   GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1UL << arg->pin);
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
-  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  pinMode(arg->pin, flags_to_mode(flags, arg->pin));  // NOLINT
+  auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
+  if (arg->pin < 16) {
+    if (flags & gpio::FLAG_OUTPUT) {
+      *arg->mode_set_reg = arg->mask;
+    } else {
+      *arg->mode_clr_reg = arg->mask;
+    }
+    if (flags & gpio::FLAG_PULLUP) {
+      *arg->func_reg |= 1 << GPFPU;
+    } else {
+      *arg->func_reg &= ~(1 << GPFPU);
+    }
+  } else {
+    if (flags & gpio::FLAG_OUTPUT) {
+      *arg->mode_set_reg |= 1;
+    } else {
+      *arg->mode_set_reg &= ~1;
+    }
+    if (flags & gpio::FLAG_PULLDOWN) {
+      *arg->func_reg |= 1 << GP16FPD;
+    } else {
+      *arg->func_reg &= ~(1 << GP16FPD);
+    }
+  }
 }
 
 }  // namespace esphome

esphome/components/ethernet/ethernet_component.cpp

@@ -240,7 +240,7 @@ void EthernetComponent::setup() {
 }
 
 void EthernetComponent::loop() {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
 
   switch (this->state_) {
     case EthernetComponentState::STOPPED:

esphome/components/event/__init__.py

@@ -41,7 +41,7 @@ EventTrigger = event_ns.class_("EventTrigger", automation.Trigger.template())
 
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-EVENT_SCHEMA = (
+_EVENT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -58,19 +58,17 @@ EVENT_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def event_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass = cv.UNDEFINED,
     *,
-    icon: str = _UNDEF,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {}
 
-    if class_ is not _UNDEF:
+    if class_ is not cv.UNDEFINED:
         schema[cv.GenerateID()] = cv.declare_id(class_)
 
     for key, default, validator in [
@@ -78,10 +76,15 @@ def event_schema(
         (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
     ]:
-        if default is not _UNDEF:
+        if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
 
-    return EVENT_SCHEMA.extend(schema)
+    return _EVENT_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+EVENT_SCHEMA = event_schema()
+EVENT_SCHEMA.add_extra(cv.deprecated_schema_constant("event"))
 
 
 async def setup_event_core_(var, config, *, event_types: list[str]):

esphome/components/factory_reset/switch/__init__.py

@@ -1,14 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ENTITY_CATEGORY,
-    CONF_ICON,
-    CONF_ID,
-    CONF_INVERTED,
-    ENTITY_CATEGORY_CONFIG,
-    ICON_RESTART_ALERT,
-)
+from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_RESTART_ALERT
 
 from .. import factory_reset_ns
 
@@ -16,21 +9,14 @@ FactoryResetSwitch = factory_reset_ns.class_(
     "FactoryResetSwitch", switch.Switch, cg.Component
 )
 
-CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(FactoryResetSwitch),
-        cv.Optional(CONF_INVERTED): cv.invalid(
-            "Factory Reset switches do not support inverted mode!"
-        ),
-        cv.Optional(CONF_ICON, default=ICON_RESTART_ALERT): cv.icon,
-        cv.Optional(
-            CONF_ENTITY_CATEGORY, default=ENTITY_CATEGORY_CONFIG
-        ): cv.entity_category,
-    }
+CONFIG_SCHEMA = switch.switch_schema(
+    FactoryResetSwitch,
+    block_inverted=True,
+    icon=ICON_RESTART_ALERT,
+    entity_category=ENTITY_CATEGORY_CONFIG,
 ).extend(cv.COMPONENT_SCHEMA)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await switch.new_switch(config)
     await cg.register_component(var, config)
-    await switch.register_switch(var, config)

esphome/components/fan/__init__.py

@@ -5,6 +5,10 @@ from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DIRECTION,
+    CONF_DIRECTION_COMMAND_TOPIC,
+    CONF_DIRECTION_STATE_TOPIC,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
     CONF_OFF_SPEED_CYCLE,
@@ -80,16 +84,21 @@ FanPresetSetTrigger = fan_ns.class_(
 FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
 FanIsOffCondition = fan_ns.class_("FanIsOffCondition", automation.Condition.template())
 
-FAN_SCHEMA = (
+_FAN_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
         {
-            cv.GenerateID(): cv.declare_id(Fan),
             cv.Optional(CONF_RESTORE_MODE, default="ALWAYS_OFF"): cv.enum(
                 RESTORE_MODES, upper=True, space="_"
             ),
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTFanComponent),
+            cv.Optional(CONF_DIRECTION_STATE_TOPIC): cv.All(
+                cv.requires_component("mqtt"), cv.publish_topic
+            ),
+            cv.Optional(CONF_DIRECTION_COMMAND_TOPIC): cv.All(
+                cv.requires_component("mqtt"), cv.subscribe_topic
+            ),
             cv.Optional(CONF_OSCILLATION_STATE_TOPIC): cv.All(
                 cv.requires_component("mqtt"), cv.publish_topic
             ),
@@ -151,6 +160,37 @@ FAN_SCHEMA = (
     )
 )
 
+
+def fan_schema(
+    class_: cg.Pvariable,
+    *,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+    default_restore_mode: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {
+        cv.GenerateID(): cv.declare_id(class_),
+    }
+
+    for key, default, validator in [
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+        (
+            CONF_RESTORE_MODE,
+            default_restore_mode,
+            cv.enum(RESTORE_MODES, upper=True, space="_"),
+        ),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _FAN_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+FAN_SCHEMA = fan_schema(Fan)
+FAN_SCHEMA.add_extra(cv.deprecated_schema_constant("fan"))
+
 _PRESET_MODES_SCHEMA = cv.All(
     cv.ensure_list(cv.string_strict),
     cv.Length(min=1),
@@ -193,6 +233,14 @@ async def setup_fan_core_(var, config):
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
+        if (
+            direction_state_topic := config.get(CONF_DIRECTION_STATE_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_direction_state_topic(direction_state_topic))
+        if (
+            direction_command_topic := config.get(CONF_DIRECTION_COMMAND_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_direction_command_topic(direction_command_topic))
         if (
             oscillation_state_topic := config.get(CONF_OSCILLATION_STATE_TOPIC)
         ) is not None:
@@ -251,10 +299,9 @@ async def register_fan(var, config):
     await setup_fan_core_(var, config)
 
 
-async def create_fan_state(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+async def new_fan(config, *args):
+    var = cg.new_Pvariable(config[CONF_ID], *args)
     await register_fan(var, config)
-    await cg.register_component(var, config)
     return var
 
 

esphome/components/fastled_base/__init__.py

@@ -40,9 +40,6 @@ async def new_fastled_light(config):
     if CONF_MAX_REFRESH_RATE in config:
         cg.add(var.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
 
+    cg.add_library("fastled/FastLED", "3.9.16")
     await light.register_light(var, config)
-    # https://github.com/FastLED/FastLED/blob/master/library.json
-    # 3.3.3 has an issue on ESP32 with RMT and fastled_clockless:
-    # https://github.com/esphome/issues/issues/1375
-    cg.add_library("fastled/FastLED", "3.3.2")
     return var

esphome/components/fastled_base/fastled_light.cpp

@@ -34,7 +34,7 @@ void FastLEDLightOutput::write_state(light::LightState *state) {
   this->mark_shown_();
 
   ESP_LOGVV(TAG, "Writing RGB values to bus...");
-  this->controller_->showLeds();
+  this->controller_->showLeds(this->state_parent_->current_values.get_brightness() * 255);
 }
 
 }  // namespace fastled_base

esphome/components/feedback/cover.py

@@ -7,7 +7,6 @@ from esphome.const import (
     CONF_CLOSE_ACTION,
     CONF_CLOSE_DURATION,
     CONF_CLOSE_ENDSTOP,
-    CONF_ID,
     CONF_MAX_DURATION,
     CONF_OPEN_ACTION,
     CONF_OPEN_DURATION,
@@ -50,36 +49,43 @@ def validate_infer_endstop(config):
     return config
 
 
-CONFIG_FEEDBACK_COVER_BASE_SCHEMA = cover.COVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(FeedbackCover),
-        cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_OPEN_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_OPEN_OBSTACLE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_CLOSE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_CLOSE_OBSTACLE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_MAX_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
-        cv.Optional(CONF_ASSUMED_STATE): cv.boolean,
-        cv.Optional(
-            CONF_UPDATE_INTERVAL, "1000ms"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_INFER_ENDSTOP_FROM_MOVEMENT, False): cv.boolean,
-        cv.Optional(
-            CONF_DIRECTION_CHANGE_WAIT_TIME
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(
-            CONF_ACCELERATION_WAIT_TIME, "0s"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_OBSTACLE_ROLLBACK, default="10%"): cv.percentage,
-    },
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_FEEDBACK_COVER_BASE_SCHEMA = (
+    cover.cover_schema(FeedbackCover)
+    .extend(
+        {
+            cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_OPEN_SENSOR): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_OPEN_OBSTACLE_SENSOR): cv.use_id(
+                binary_sensor.BinarySensor
+            ),
+            cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_CLOSE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_CLOSE_OBSTACLE_SENSOR): cv.use_id(
+                binary_sensor.BinarySensor
+            ),
+            cv.Optional(CONF_MAX_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
+            cv.Optional(CONF_ASSUMED_STATE): cv.boolean,
+            cv.Optional(
+                CONF_UPDATE_INTERVAL, "1000ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_INFER_ENDSTOP_FROM_MOVEMENT, False): cv.boolean,
+            cv.Optional(
+                CONF_DIRECTION_CHANGE_WAIT_TIME
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_ACCELERATION_WAIT_TIME, "0s"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_OBSTACLE_ROLLBACK, default="10%"): cv.percentage,
+        },
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 CONFIG_SCHEMA = cv.All(
@@ -90,9 +96,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     # STOP
     await automation.build_automation(

esphome/components/feedback/feedback_cover.cpp

@@ -1,6 +1,7 @@
 #include "feedback_cover.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace feedback {
@@ -220,7 +221,7 @@ void FeedbackCover::set_open_obstacle_sensor(binary_sensor::BinarySensor *open_o
 void FeedbackCover::loop() {
   if (this->current_operation == COVER_OPERATION_IDLE)
     return;
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
 
   // Recompute position every loop cycle
   this->recompute_position_();