Merge branch 'dev' into timeout_filter_scheduler_churn_fix

ahead of optimization effort in https://github.com/esphome/esphome/pull/11922

esphome/components/binary_sensor/automation.cpp

@@ -1,12 +1,11 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void binary_sensor::MultiClickTrigger::on_state_(bool state) {
+void MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -67,7 +66,7 @@ void binary_sensor::MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
+void MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
   this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
@@ -79,7 +78,7 @@ void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -90,19 +89,19 @@ void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
   });
 }
-void binary_sensor::MultiClickTrigger::cancel() {
+void MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void binary_sensor::MultiClickTrigger::trigger_() {
+void MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -118,5 +117,4 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/automation.h

@@ -9,8 +9,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome {
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -172,5 +171,4 @@ template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts..
   BinarySensor *sensor_;
 };
 
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/binary_sensor.cpp

@@ -3,9 +3,7 @@
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
@@ -63,6 +61,4 @@ void BinarySensor::add_filters(std::initializer_list<Filter *> filters) {
 }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/binary_sensor.h

@@ -6,9 +6,7 @@
 
 #include <initializer_list>
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 class BinarySensor;
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
@@ -70,5 +68,4 @@ class BinarySensorInitiallyOff : public BinarySensor {
   bool has_state() const override { return true; }
 };
 
-}  // namespace binary_sensor
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/filter.cpp

@@ -2,9 +2,7 @@
 
 #include "binary_sensor.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
@@ -132,6 +130,4 @@ optional<bool> SettleFilter::new_value(bool value) {
 
 float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/binary_sensor/filter.h

@@ -4,9 +4,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome {
-
-namespace binary_sensor {
+namespace esphome::binary_sensor {
 
 class BinarySensor;
 
@@ -139,6 +137,4 @@ class SettleFilter : public Filter, public Component {
   bool steady_{true};
 };
 
-}  // namespace binary_sensor
-
-}  // namespace esphome
+}  // namespace esphome::binary_sensor

esphome/components/font/__init__.py

@@ -36,7 +36,6 @@ from esphome.const import (
     CONF_WEIGHT,
 )
 from esphome.core import CORE, HexInt
-from esphome.helpers import cpp_string_escape
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,7 +49,6 @@ font_ns = cg.esphome_ns.namespace("font")
 
 Font = font_ns.class_("Font")
 Glyph = font_ns.class_("Glyph")
-GlyphData = font_ns.struct("GlyphData")
 
 CONF_BPP = "bpp"
 CONF_EXTRAS = "extras"
@@ -463,7 +461,7 @@ FONT_SCHEMA = cv.Schema(
             )
         ),
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(GlyphData),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
     },
 )
 
@@ -583,22 +581,15 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        cg.StructInitializer(
-            GlyphData,
-            (
-                "a_char",
-                cg.RawExpression(f"(const uint8_t *){cpp_string_escape(x.glyph)}"),
-            ),
-            (
-                "data",
-                cg.RawExpression(f"{str(prog_arr)} + {str(y - len(x.bitmap_data))}"),
-            ),
-            ("advance", x.advance),
-            ("offset_x", x.offset_x),
-            ("offset_y", x.offset_y),
-            ("width", x.width),
-            ("height", x.height),
-        )
+        [
+            x.glyph,
+            prog_arr + (y - len(x.bitmap_data)),
+            x.advance,
+            x.offset_x,
+            x.offset_y,
+            x.width,
+            x.height,
+        ]
         for (x, y) in zip(
             glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )

esphome/components/font/font.cpp

@@ -9,20 +9,19 @@ namespace font {
 
 static const char *const TAG = "font";
 
-const uint8_t *Glyph::get_char() const { return this->glyph_data_->a_char; }
 // Compare the char at the string position with this char.
 // Return true if this char is less than or equal the other.
 bool Glyph::compare_to(const uint8_t *str) const {
   // 1 -> this->char_
   // 2 -> str
   for (uint32_t i = 0;; i++) {
-    if (this->glyph_data_->a_char[i] == '\0')
+    if (this->a_char[i] == '\0')
       return true;
     if (str[i] == '\0')
       return false;
-    if (this->glyph_data_->a_char[i] > str[i])
+    if (this->a_char[i] > str[i])
       return false;
-    if (this->glyph_data_->a_char[i] < str[i])
+    if (this->a_char[i] < str[i])
       return true;
   }
   // this should not happen
@@ -30,35 +29,32 @@ bool Glyph::compare_to(const uint8_t *str) const {
 }
 int Glyph::match_length(const uint8_t *str) const {
   for (uint32_t i = 0;; i++) {
-    if (this->glyph_data_->a_char[i] == '\0')
+    if (this->a_char[i] == '\0')
       return i;
-    if (str[i] != this->glyph_data_->a_char[i])
+    if (str[i] != this->a_char[i])
       return 0;
   }
   // this should not happen
   return 0;
 }
 void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
-  *x1 = this->glyph_data_->offset_x;
-  *y1 = this->glyph_data_->offset_y;
-  *width = this->glyph_data_->width;
-  *height = this->glyph_data_->height;
+  *x1 = this->offset_x;
+  *y1 = this->offset_y;
+  *width = this->width;
+  *height = this->height;
 }
 
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : baseline_(baseline),
+    : glyphs_(ConstVector(data, data_nr)),
+      baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
-      bpp_(bpp) {
-  glyphs_.reserve(data_nr);
-  for (int i = 0; i < data_nr; ++i)
-    glyphs_.emplace_back(&data[i]);
-}
-int Font::match_next_glyph(const uint8_t *str, int *match_length) {
+      bpp_(bpp) {}
+int Font::match_next_glyph(const uint8_t *str, int *match_length) const {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
@@ -88,18 +84,18 @@ void Font::measure(const char *str, int *width, int *x_offset, int *baseline, in
     if (glyph_n < 0) {
       // Unknown char, skip
       if (!this->get_glyphs().empty())
-        x += this->get_glyphs()[0].glyph_data_->advance;
+        x += this->get_glyphs()[0].advance;
       i++;
       continue;
     }
 
     const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph.glyph_data_->offset_x;
+      min_x = glyph.offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
+      min_x = std::min(min_x, x + glyph.offset_x);
     }
-    x += glyph.glyph_data_->advance;
+    x += glyph.advance;
 
     i += match_length;
     has_char = true;
@@ -118,7 +114,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
       // Unknown char, skip
       ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
       if (!this->get_glyphs().empty()) {
-        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->advance;
+        uint8_t glyph_width = this->get_glyphs()[0].advance;
         display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
@@ -130,7 +126,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
     const Glyph &glyph = this->get_glyphs()[glyph_n];
     glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
 
-    const uint8_t *data = glyph.glyph_data_->data;
+    const uint8_t *data = glyph.data;
     const int max_x = x_at + scan_x1 + scan_width;
     const int max_y = y_start + scan_y1 + scan_height;
 
@@ -168,7 +164,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph.glyph_data_->advance;
+    x_at += glyph.advance;
 
     i += match_length;
   }

esphome/components/font/font.h

@@ -12,21 +12,19 @@ namespace font {
 
 class Font;
 
-struct GlyphData {
-  const uint8_t *a_char;
-  const uint8_t *data;
-  int advance;
-  int offset_x;
-  int offset_y;
-  int width;
-  int height;
-};
-
 class Glyph {
  public:
-  Glyph(const GlyphData *data) : glyph_data_(data) {}
+  constexpr Glyph(const char *a_char, const uint8_t *data, int advance, int offset_x, int offset_y, int width,
+                  int height)
+      : a_char(a_char),
+        data(data),
+        advance(advance),
+        offset_x(offset_x),
+        offset_y(offset_y),
+        width(width),
+        height(height) {}
 
-  const uint8_t *get_char() const;
+  const uint8_t *get_char() const { return reinterpret_cast<const uint8_t *>(this->a_char); }
 
   bool compare_to(const uint8_t *str) const;
 
@@ -34,12 +32,16 @@ class Glyph {
 
   void scan_area(int *x1, int *y1, int *width, int *height) const;
 
-  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
+  const char *a_char;
+  const uint8_t *data;
+  int advance;
+  int offset_x;
+  int offset_y;
+  int width;
+  int height;
 
  protected:
   friend Font;
-
-  const GlyphData *glyph_data_;
 };
 
 class Font
@@ -50,8 +52,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A vector of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs in data.
+   * @param data A list of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs
    * @param baseline The y-offset from the top of the text to the baseline.
    * @param height The y-offset from the top of the text to the bottom.
    * @param descender The y-offset from the baseline to the lowest stroke in the font (e.g. from letters like g or p).
@@ -59,10 +61,10 @@ class Font
    * @param capheight The height of capital letters, usually measured at the "X" glyph.
    * @param bpp The bits per pixel used for this font. Used to read data out of the glyph bitmaps.
    */
-  Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
        uint8_t bpp = 1);
 
-  int match_next_glyph(const uint8_t *str, int *match_length);
+  int match_next_glyph(const uint8_t *str, int *match_length) const;
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -78,10 +80,10 @@ class Font
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
 
-  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
+  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
 
  protected:
-  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
+  ConstVector<Glyph> glyphs_;
   int baseline_;
   int height_;
   int descender_;

esphome/components/ld2410/sensor.py

@@ -31,35 +31,83 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -73,7 +121,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -81,7 +135,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,36 +31,84 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_LIGHTBULB,
             unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
         ),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
+            filters=[
+                {
+                    "timeout": {
+                        "timeout": cv.TimePeriod(milliseconds=1000),
+                        "value": "last",
+                    }
+                },
+                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+            ],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -74,7 +122,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -82,7 +136,13 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
+                        {
+                            "timeout": {
+                                "timeout": cv.TimePeriod(milliseconds=1000),
+                                "value": "last",
+                            }
+                        },
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/lvgl/font.cpp

@@ -43,7 +43,7 @@ FontEngine::FontEngine(font::Font *esp_font) : font_(esp_font) {
 
 const lv_font_t *FontEngine::get_lv_font() { return &this->lv_font_; }
 
-const font::GlyphData *FontEngine::get_glyph_data(uint32_t unicode_letter) {
+const font::Glyph *FontEngine::get_glyph_data(uint32_t unicode_letter) {
   if (unicode_letter == last_letter_)
     return this->last_data_;
   uint8_t unicode[5];
@@ -67,7 +67,7 @@ const font::GlyphData *FontEngine::get_glyph_data(uint32_t unicode_letter) {
   int glyph_n = this->font_->match_next_glyph(unicode, &match_length);
   if (glyph_n < 0)
     return nullptr;
-  this->last_data_ = this->font_->get_glyphs()[glyph_n].get_glyph_data();
+  this->last_data_ = &this->font_->get_glyphs()[glyph_n];
   this->last_letter_ = unicode_letter;
   return this->last_data_;
 }

esphome/components/lvgl/lvgl_esphome.h

@@ -140,7 +140,7 @@ class FontEngine {
   FontEngine(font::Font *esp_font);
   const lv_font_t *get_lv_font();
 
-  const font::GlyphData *get_glyph_data(uint32_t unicode_letter);
+  const font::Glyph *get_glyph_data(uint32_t unicode_letter);
   uint16_t baseline{};
   uint16_t height{};
   uint8_t bpp{};
@@ -148,7 +148,7 @@ class FontEngine {
  protected:
   font::Font *font_{};
   uint32_t last_letter_{};
-  const font::GlyphData *last_data_{};
+  const font::Glyph *last_data_{};
   lv_font_t lv_font_{};
 };
 #endif  // USE_LVGL_FONT

esphome/components/sensor/__init__.py

@@ -271,6 +271,9 @@ ThrottleWithPriorityFilter = sensor_ns.class_(
     "ThrottleWithPriorityFilter", ValueListFilter
 )
 TimeoutFilter = sensor_ns.class_("TimeoutFilter", Filter, cg.Component)
+TimeoutFilterConfigured = sensor_ns.class_(
+    "TimeoutFilterConfigured", Filter, cg.Component
+)
 DebounceFilter = sensor_ns.class_("DebounceFilter", Filter, cg.Component)
 HeartbeatFilter = sensor_ns.class_("HeartbeatFilter", Filter, cg.Component)
 DeltaFilter = sensor_ns.class_("DeltaFilter", Filter)
@@ -684,8 +687,13 @@ TIMEOUT_SCHEMA = cv.maybe_simple_value(
 @FILTER_REGISTRY.register("timeout", TimeoutFilter, TIMEOUT_SCHEMA)
 async def timeout_filter_to_code(config, filter_id):
     if config[CONF_VALUE] == "last":
+        # Use TimeoutFilter for "last" mode (smaller, more common - LD2450, LD2412, etc.)
         var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT])
     else:
+        # Use TimeoutFilterConfigured for configured value mode
+        # Change the type to TimeoutFilterConfigured (similar to stateless lambda pattern)
+        filter_id = filter_id.copy()
+        filter_id.type = TimeoutFilterConfigured
         template_ = await cg.templatable(config[CONF_VALUE], [], float)
         var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], template_)
     await cg.register_component(var, {})

esphome/components/sensor/filter.cpp

@@ -339,20 +339,43 @@ void OrFilter::initialize(Sensor *parent, Filter *next) {
   this->phi_.initialize(parent, nullptr);
 }
 
-// TimeoutFilter
-optional<float> TimeoutFilter::new_value(float value) {
-  if (this->value_.has_value()) {
-    this->set_timeout("timeout", this->time_period_, [this]() { this->output(this->value_.value().value()); });
-  } else {
-    this->set_timeout("timeout", this->time_period_, [this, value]() { this->output(value); });
+// TimeoutFilterBase - shared loop logic
+void TimeoutFilterBase::loop() {
+  // Check if timeout period has elapsed
+  // Use cached loop start time to avoid repeated millis() calls
+  const uint32_t now = App.get_loop_component_start_time();
+  if (now - this->timeout_start_time_ >= this->time_period_) {
+    // Timeout fired - get output value from derived class and output it
+    this->output(this->get_output_value());
+
+    // Disable loop until next value arrives
+    this->disable_loop();
   }
+}
+
+float TimeoutFilterBase::get_setup_priority() const { return setup_priority::HARDWARE; }
+
+// TimeoutFilter - "last" mode implementation
+optional<float> TimeoutFilter::new_value(float value) {
+  // Store the value to output when timeout fires
+  this->pending_value_ = value;
+
+  // Record when timeout started and enable loop
+  this->timeout_start_time_ = millis();
+  this->enable_loop();
+
   return value;
 }
 
-TimeoutFilter::TimeoutFilter(uint32_t time_period) : time_period_(time_period) {}
-TimeoutFilter::TimeoutFilter(uint32_t time_period, const TemplatableValue<float> &new_value)
-    : time_period_(time_period), value_(new_value) {}
-float TimeoutFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
+// TimeoutFilterConfigured - configured value mode implementation
+optional<float> TimeoutFilterConfigured::new_value(float value) {
+  // Record when timeout started and enable loop
+  // Note: we don't store the incoming value since we have a configured value
+  this->timeout_start_time_ = millis();
+  this->enable_loop();
+
+  return value;
+}
 
 // DebounceFilter
 optional<float> DebounceFilter::new_value(float value) {

esphome/components/sensor/filter.h

@@ -380,18 +380,46 @@ class ThrottleWithPriorityFilter : public ValueListFilter {
   uint32_t min_time_between_inputs_;
 };
 
-class TimeoutFilter : public Filter, public Component {
+// Base class for timeout filters - contains common loop logic
+class TimeoutFilterBase : public Filter, public Component {
  public:
-  explicit TimeoutFilter(uint32_t time_period);
-  explicit TimeoutFilter(uint32_t time_period, const TemplatableValue<float> &new_value);
-
-  optional<float> new_value(float value) override;
-
+  void loop() override;
   float get_setup_priority() const override;
 
  protected:
-  uint32_t time_period_;
-  optional<TemplatableValue<float>> value_;
+  explicit TimeoutFilterBase(uint32_t time_period) : time_period_(time_period) { this->disable_loop(); }
+  virtual float get_output_value() = 0;
+
+  uint32_t time_period_;            // 4 bytes (timeout duration in ms)
+  uint32_t timeout_start_time_{0};  // 4 bytes (when the timeout was started)
+  // Total base: 8 bytes
+};
+
+// Timeout filter for "last" mode - outputs the last received value after timeout
+class TimeoutFilter : public TimeoutFilterBase {
+ public:
+  explicit TimeoutFilter(uint32_t time_period) : TimeoutFilterBase(time_period) {}
+
+  optional<float> new_value(float value) override;
+
+ protected:
+  float get_output_value() override { return this->pending_value_; }
+  float pending_value_{0};  // 4 bytes (value to output when timeout fires)
+  // Total: 8 (base) + 4 = 12 bytes + vtable ptr + Component overhead
+};
+
+// Timeout filter with configured value - evaluates TemplatableValue after timeout
+class TimeoutFilterConfigured : public TimeoutFilterBase {
+ public:
+  explicit TimeoutFilterConfigured(uint32_t time_period, const TemplatableValue<float> &new_value)
+      : TimeoutFilterBase(time_period), value_(new_value) {}
+
+  optional<float> new_value(float value) override;
+
+ protected:
+  float get_output_value() override { return this->value_.value(); }
+  TemplatableValue<float> value_;  // 16 bytes (configured output value, can be lambda)
+  // Total: 8 (base) + 16 = 24 bytes + vtable ptr + Component overhead
 };
 
 class DebounceFilter : public Filter, public Component {

esphome/core/helpers.h

@@ -111,6 +111,23 @@ template<> constexpr int64_t byteswap(int64_t n) { return __builtin_bswap64(n);
 /// @name Container utilities
 ///@{
 
+/// Lightweight read-only view over a const array stored in RODATA (will typically be in flash memory)
+/// Avoids copying data from flash to RAM by keeping a pointer to the flash data.
+/// Similar to std::span but with minimal overhead for embedded systems.
+
+template<typename T> class ConstVector {
+ public:
+  constexpr ConstVector(const T *data, size_t size) : data_(data), size_(size) {}
+
+  const constexpr T &operator[](size_t i) const { return data_[i]; }
+  constexpr size_t size() const { return size_; }
+  constexpr bool empty() const { return size_ == 0; }
+
+ protected:
+  const T *data_;
+  size_t size_;
+};
+
 /// Minimal static vector - saves memory by avoiding std::vector overhead
 template<typename T, size_t N> class StaticVector {
  public:

esphome/core/scheduler.cpp

@@ -609,13 +609,12 @@ uint64_t Scheduler::millis_64_(uint32_t now) {
   if (now < last && (last - now) > HALF_MAX_UINT32) {
     this->millis_major_++;
     major++;
+    this->last_millis_ = now;
 #ifdef ESPHOME_DEBUG_SCHEDULER
     ESP_LOGD(TAG, "Detected true 32-bit rollover at %" PRIu32 "ms (was %" PRIu32 ")", now, last);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
-  }
-
-  // Only update if time moved forward
-  if (now > last) {
+  } else if (now > last) {
+    // Only update if time moved forward
     this->last_millis_ = now;
   }
 

tests/integration/fixtures/sensor_timeout_filter.yaml

@@ -0,0 +1,150 @@
+esphome:
+  name: test-timeout-filters
+
+host:
+api:
+  batch_delay: 0ms  # Disable batching to receive all state updates
+logger:
+  level: DEBUG
+
+# Template sensors that we'll use to publish values
+sensor:
+  - platform: template
+    name: "Source Timeout Last"
+    id: source_timeout_last
+    accuracy_decimals: 1
+
+  - platform: template
+    name: "Source Timeout Reset"
+    id: source_timeout_reset
+    accuracy_decimals: 1
+
+  - platform: template
+    name: "Source Timeout Static"
+    id: source_timeout_static
+    accuracy_decimals: 1
+
+  - platform: template
+    name: "Source Timeout Lambda"
+    id: source_timeout_lambda
+    accuracy_decimals: 1
+
+  # Test 1: TimeoutFilter - "last" mode (outputs last received value)
+  - platform: copy
+    source_id: source_timeout_last
+    name: "Timeout Last Sensor"
+    id: timeout_last_sensor
+    filters:
+      - timeout:
+          timeout: 100ms
+          value: last  # Explicitly specify "last" mode to use TimeoutFilter class
+
+  # Test 2: TimeoutFilter - reset behavior (same filter, different source)
+  - platform: copy
+    source_id: source_timeout_reset
+    name: "Timeout Reset Sensor"
+    id: timeout_reset_sensor
+    filters:
+      - timeout:
+          timeout: 100ms
+          value: last  # Explicitly specify "last" mode
+
+  # Test 3: TimeoutFilterConfigured - static value mode
+  - platform: copy
+    source_id: source_timeout_static
+    name: "Timeout Static Sensor"
+    id: timeout_static_sensor
+    filters:
+      - timeout:
+          timeout: 100ms
+          value: 99.9
+
+  # Test 4: TimeoutFilterConfigured - lambda mode
+  - platform: copy
+    source_id: source_timeout_lambda
+    name: "Timeout Lambda Sensor"
+    id: timeout_lambda_sensor
+    filters:
+      - timeout:
+          timeout: 100ms
+          value: !lambda "return -1.0;"
+
+# Scripts to publish values with controlled timing
+script:
+  # Test 1: Single value followed by timeout
+  - id: test_timeout_last_script
+    then:
+      # Publish initial value
+      - sensor.template.publish:
+          id: source_timeout_last
+          state: 42.0
+      # Wait for timeout to fire (100ms + margin)
+      - delay: 150ms
+
+  # Test 2: Multiple values before timeout (should reset timer)
+  - id: test_timeout_reset_script
+    then:
+      # Publish first value
+      - sensor.template.publish:
+          id: source_timeout_reset
+          state: 10.0
+      # Wait 50ms (halfway to timeout)
+      - delay: 50ms
+      # Publish second value (resets timeout)
+      - sensor.template.publish:
+          id: source_timeout_reset
+          state: 20.0
+      # Wait 50ms (halfway to timeout again)
+      - delay: 50ms
+      # Publish third value (resets timeout)
+      - sensor.template.publish:
+          id: source_timeout_reset
+          state: 30.0
+      # Wait for timeout to fire (100ms + margin)
+      - delay: 150ms
+
+  # Test 3: Static value timeout
+  - id: test_timeout_static_script
+    then:
+      # Publish initial value
+      - sensor.template.publish:
+          id: source_timeout_static
+          state: 55.5
+      # Wait for timeout to fire
+      - delay: 150ms
+
+  # Test 4: Lambda value timeout
+  - id: test_timeout_lambda_script
+    then:
+      # Publish initial value
+      - sensor.template.publish:
+          id: source_timeout_lambda
+          state: 77.7
+      # Wait for timeout to fire
+      - delay: 150ms
+
+# Buttons to trigger each test scenario
+button:
+  - platform: template
+    name: "Test Timeout Last Button"
+    id: test_timeout_last_button
+    on_press:
+      - script.execute: test_timeout_last_script
+
+  - platform: template
+    name: "Test Timeout Reset Button"
+    id: test_timeout_reset_button
+    on_press:
+      - script.execute: test_timeout_reset_script
+
+  - platform: template
+    name: "Test Timeout Static Button"
+    id: test_timeout_static_button
+    on_press:
+      - script.execute: test_timeout_static_script
+
+  - platform: template
+    name: "Test Timeout Lambda Button"
+    id: test_timeout_lambda_button
+    on_press:
+      - script.execute: test_timeout_lambda_script

tests/integration/test_sensor_timeout_filter.py

@@ -0,0 +1,185 @@
+"""Test sensor timeout filter functionality."""
+
+from __future__ import annotations
+
+import asyncio
+
+from aioesphomeapi import EntityState, SensorState
+import pytest
+
+from .state_utils import InitialStateHelper, build_key_to_entity_mapping
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_sensor_timeout_filter(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test TimeoutFilter and TimeoutFilterConfigured with all modes."""
+    loop = asyncio.get_running_loop()
+
+    # Track state changes for all sensors
+    timeout_last_states: list[float] = []
+    timeout_reset_states: list[float] = []
+    timeout_static_states: list[float] = []
+    timeout_lambda_states: list[float] = []
+
+    # Futures for each test scenario
+    test1_complete = loop.create_future()  # TimeoutFilter - last mode
+    test2_complete = loop.create_future()  # TimeoutFilter - reset behavior
+    test3_complete = loop.create_future()  # TimeoutFilterConfigured - static value
+    test4_complete = loop.create_future()  # TimeoutFilterConfigured - lambda
+
+    def on_state(state: EntityState) -> None:
+        """Track sensor state updates."""
+        if not isinstance(state, SensorState):
+            return
+
+        if state.missing_state:
+            return
+
+        sensor_name = key_to_sensor.get(state.key)
+
+        # Test 1: TimeoutFilter - last mode
+        if sensor_name == "timeout_last_sensor":
+            timeout_last_states.append(state.state)
+            # Expect 2 values: initial 42.0 + timeout fires with 42.0
+            if len(timeout_last_states) >= 2 and not test1_complete.done():
+                test1_complete.set_result(True)
+
+        # Test 2: TimeoutFilter - reset behavior
+        elif sensor_name == "timeout_reset_sensor":
+            timeout_reset_states.append(state.state)
+            # Expect 4 values: 10.0, 20.0, 30.0, then timeout fires with 30.0
+            if len(timeout_reset_states) >= 4 and not test2_complete.done():
+                test2_complete.set_result(True)
+
+        # Test 3: TimeoutFilterConfigured - static value
+        elif sensor_name == "timeout_static_sensor":
+            timeout_static_states.append(state.state)
+            # Expect 2 values: initial 55.5 + timeout fires with 99.9
+            if len(timeout_static_states) >= 2 and not test3_complete.done():
+                test3_complete.set_result(True)
+
+        # Test 4: TimeoutFilterConfigured - lambda
+        elif sensor_name == "timeout_lambda_sensor":
+            timeout_lambda_states.append(state.state)
+            # Expect 2 values: initial 77.7 + timeout fires with -1.0
+            if len(timeout_lambda_states) >= 2 and not test4_complete.done():
+                test4_complete.set_result(True)
+
+    async with (
+        run_compiled(yaml_config),
+        api_client_connected() as client,
+    ):
+        entities, services = await client.list_entities_services()
+
+        key_to_sensor = build_key_to_entity_mapping(
+            entities,
+            [
+                "timeout_last_sensor",
+                "timeout_reset_sensor",
+                "timeout_static_sensor",
+                "timeout_lambda_sensor",
+            ],
+        )
+
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        # Helper to find buttons by object_id substring
+        def find_button(object_id_substring: str) -> int:
+            """Find a button by object_id substring and return its key."""
+            button = next(
+                (e for e in entities if object_id_substring in e.object_id.lower()),
+                None,
+            )
+            assert button is not None, f"Button '{object_id_substring}' not found"
+            return button.key
+
+        # Find all test buttons
+        test1_button_key = find_button("test_timeout_last_button")
+        test2_button_key = find_button("test_timeout_reset_button")
+        test3_button_key = find_button("test_timeout_static_button")
+        test4_button_key = find_button("test_timeout_lambda_button")
+
+        # === Test 1: TimeoutFilter - last mode ===
+        client.button_command(test1_button_key)
+        try:
+            await asyncio.wait_for(test1_complete, timeout=2.0)
+        except TimeoutError:
+            pytest.fail(f"Test 1 timeout. Received states: {timeout_last_states}")
+
+        assert len(timeout_last_states) == 2, (
+            f"Test 1: Should have 2 states, got {len(timeout_last_states)}: {timeout_last_states}"
+        )
+        assert timeout_last_states[0] == pytest.approx(42.0), (
+            f"Test 1: First state should be 42.0, got {timeout_last_states[0]}"
+        )
+        assert timeout_last_states[1] == pytest.approx(42.0), (
+            f"Test 1: Timeout should output last value (42.0), got {timeout_last_states[1]}"
+        )
+
+        # === Test 2: TimeoutFilter - reset behavior ===
+        client.button_command(test2_button_key)
+        try:
+            await asyncio.wait_for(test2_complete, timeout=2.0)
+        except TimeoutError:
+            pytest.fail(f"Test 2 timeout. Received states: {timeout_reset_states}")
+
+        assert len(timeout_reset_states) == 4, (
+            f"Test 2: Should have 4 states, got {len(timeout_reset_states)}: {timeout_reset_states}"
+        )
+        assert timeout_reset_states[0] == pytest.approx(10.0), (
+            f"Test 2: First state should be 10.0, got {timeout_reset_states[0]}"
+        )
+        assert timeout_reset_states[1] == pytest.approx(20.0), (
+            f"Test 2: Second state should be 20.0, got {timeout_reset_states[1]}"
+        )
+        assert timeout_reset_states[2] == pytest.approx(30.0), (
+            f"Test 2: Third state should be 30.0, got {timeout_reset_states[2]}"
+        )
+        assert timeout_reset_states[3] == pytest.approx(30.0), (
+            f"Test 2: Timeout should output last value (30.0), got {timeout_reset_states[3]}"
+        )
+
+        # === Test 3: TimeoutFilterConfigured - static value ===
+        client.button_command(test3_button_key)
+        try:
+            await asyncio.wait_for(test3_complete, timeout=2.0)
+        except TimeoutError:
+            pytest.fail(f"Test 3 timeout. Received states: {timeout_static_states}")
+
+        assert len(timeout_static_states) == 2, (
+            f"Test 3: Should have 2 states, got {len(timeout_static_states)}: {timeout_static_states}"
+        )
+        assert timeout_static_states[0] == pytest.approx(55.5), (
+            f"Test 3: First state should be 55.5, got {timeout_static_states[0]}"
+        )
+        assert timeout_static_states[1] == pytest.approx(99.9), (
+            f"Test 3: Timeout should output configured value (99.9), got {timeout_static_states[1]}"
+        )
+
+        # === Test 4: TimeoutFilterConfigured - lambda ===
+        client.button_command(test4_button_key)
+        try:
+            await asyncio.wait_for(test4_complete, timeout=2.0)
+        except TimeoutError:
+            pytest.fail(f"Test 4 timeout. Received states: {timeout_lambda_states}")
+
+        assert len(timeout_lambda_states) == 2, (
+            f"Test 4: Should have 2 states, got {len(timeout_lambda_states)}: {timeout_lambda_states}"
+        )
+        assert timeout_lambda_states[0] == pytest.approx(77.7), (
+            f"Test 4: First state should be 77.7, got {timeout_lambda_states[0]}"
+        )
+        assert timeout_lambda_states[1] == pytest.approx(-1.0), (
+            f"Test 4: Timeout should evaluate lambda (-1.0), got {timeout_lambda_states[1]}"
+        )