esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/{qspi_amoled/qspi_amoled.cpp → qspi_dbi/qspi_dbi.cpp}

@@ -1,12 +1,12 @@
 #ifdef USE_ESP_IDF
-#include "qspi_amoled.h"
+#include "qspi_dbi.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
-namespace qspi_amoled {
+namespace qspi_dbi {
 
-void QspiAmoLed::setup() {
-  esph_log_config(TAG, "Setting up QSPI_AMOLED");
+void QspiDbi::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up QSPI_DBI");
   this->spi_setup();
   if (this->enable_pin_ != nullptr) {
     this->enable_pin_->setup();
@@ -22,13 +22,17 @@ void QspiAmoLed::setup() {
   }
   this->set_timeout(120, [this] { this->write_command_(SLEEP_OUT); });
   this->set_timeout(240, [this] { this->write_init_sequence_(); });
+  if (this->draw_from_origin_)
+    check_buffer_();
 }
 
-void QspiAmoLed::update() {
+void QspiDbi::update() {
   if (!this->setup_complete_) {
     return;
   }
   this->do_update_();
+  if (this->buffer_ == nullptr || this->x_low_ > this->x_high_ || this->y_low_ > this->y_high_)
+    return;
   // Start addresses and widths/heights must be divisible by 2 (CASET/RASET restriction in datasheet)
   if (this->x_low_ % 2 == 1) {
     this->x_low_--;
@@ -42,10 +46,15 @@ void QspiAmoLed::update() {
   if (this->y_high_ % 2 == 0) {
     this->y_high_++;
   }
+  if (this->draw_from_origin_) {
+    this->x_low_ = 0;
+    this->y_low_ = 0;
+    this->x_high_ = this->width_ - 1;
+  }
   int w = this->x_high_ - this->x_low_ + 1;
   int h = this->y_high_ - this->y_low_ + 1;
-  this->draw_pixels_at(this->x_low_, this->y_low_, w, h, this->buffer_, this->color_mode_, display::COLOR_BITNESS_565,
-                       true, this->x_low_, this->y_low_, this->get_width_internal() - w - this->x_low_);
+  this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_, this->y_low_,
+                          this->width_ - w - this->x_low_);
   // invalidate watermarks
   this->x_low_ = this->width_;
   this->y_low_ = this->height_;
@@ -53,21 +62,19 @@ void QspiAmoLed::update() {
   this->y_high_ = 0;
 }
 
-void QspiAmoLed::draw_absolute_pixel_internal(int x, int y, Color color) {
+void QspiDbi::draw_absolute_pixel_internal(int x, int y, Color color) {
   if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0) {
     return;
   }
-  if (this->buffer_ == nullptr)
-    this->init_internal_(this->width_ * this->height_ * 2);
   if (this->is_failed())
     return;
+  check_buffer_();
   uint32_t pos = (y * this->width_) + x;
-  uint16_t new_color;
   bool updated = false;
   pos = pos * 2;
-  new_color = display::ColorUtil::color_to_565(color, display::ColorOrder::COLOR_ORDER_RGB);
-  if (this->buffer_[pos] != (uint8_t) (new_color >> 8)) {
-    this->buffer_[pos] = (uint8_t) (new_color >> 8);
+  uint16_t new_color = display::ColorUtil::color_to_565(color, display::ColorOrder::COLOR_ORDER_RGB);
+  if (this->buffer_[pos] != static_cast<uint8_t>(new_color >> 8)) {
+    this->buffer_[pos] = static_cast<uint8_t>(new_color >> 8);
     updated = true;
   }
   pos = pos + 1;
@@ -90,7 +97,7 @@ void QspiAmoLed::draw_absolute_pixel_internal(int x, int y, Color color) {
   }
 }
 
-void QspiAmoLed::reset_params_(bool ready) {
+void QspiDbi::reset_params_(bool ready) {
   if (!ready && !this->is_ready())
     return;
   this->write_command_(this->invert_colors_ ? INVERT_ON : INVERT_OFF);
@@ -102,55 +109,64 @@ void QspiAmoLed::reset_params_(bool ready) {
     mad |= MADCTL_MX;
   if (this->mirror_y_)
     mad |= MADCTL_MY;
-  this->write_command_(MADCTL_CMD, &mad, 1);
-  this->write_command_(BRIGHTNESS, &this->brightness_, 1);
+  this->write_command_(MADCTL_CMD, mad);
+  this->write_command_(BRIGHTNESS, this->brightness_);
+  this->write_command_(NORON);
+  this->write_command_(DISPLAY_ON);
 }
 
-void QspiAmoLed::write_init_sequence_() {
-  if (this->model_ == RM690B0) {
-    this->write_command_(PAGESEL, 0x20);
-    this->write_command_(MIPI, 0x0A);
-    this->write_command_(WRAM, 0x80);
-    this->write_command_(SWIRE1, 0x51);
-    this->write_command_(SWIRE2, 0x2E);
-    this->write_command_(PAGESEL, 0x00);
-    this->write_command_(0xC2, 0x00);
-    delay(10);
-    this->write_command_(TEON, 0x00);
-  }
-  this->write_command_(PIXFMT, 0x55);
-  this->write_command_(BRIGHTNESS, 0);
-  this->write_command_(DISPLAY_ON);
+void QspiDbi::write_init_sequence_() {
+  for (const auto &seq : this->init_sequences_) {
+    this->write_sequence_(seq);
+  }
   this->reset_params_(true);
   this->setup_complete_ = true;
-  esph_log_config(TAG, "QSPI_AMOLED setup complete");
+  ESP_LOGCONFIG(TAG, "QSPI_DBI setup complete");
 }
 
-void QspiAmoLed::set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
+void QspiDbi::set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
+  ESP_LOGVV(TAG, "Set addr %d/%d, %d/%d", x1, y1, x2, y2);
   uint8_t buf[4];
   x1 += this->offset_x_;
   x2 += this->offset_x_;
   y1 += this->offset_y_;
   y2 += this->offset_y_;
-  put16_be(buf, x1);
-  put16_be(buf + 2, x2);
-  this->write_command_(CASET, buf, sizeof buf);
   put16_be(buf, y1);
   put16_be(buf + 2, y2);
   this->write_command_(RASET, buf, sizeof buf);
+  put16_be(buf, x1);
+  put16_be(buf + 2, x2);
+  this->write_command_(CASET, buf, sizeof buf);
 }
 
-void QspiAmoLed::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
-                                display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+void QspiDbi::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
+                             display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
   if (!this->setup_complete_ || this->is_failed())
     return;
   if (w <= 0 || h <= 0)
     return;
   if (bitness != display::COLOR_BITNESS_565 || order != this->color_mode_ ||
       big_endian != (this->bit_order_ == spi::BIT_ORDER_MSB_FIRST)) {
-    return display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
-                                            x_pad);
+    return Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
+  } else if (this->draw_from_origin_) {
+    auto stride = x_offset + w + x_pad;
+    for (int y = 0; y != h; y++) {
+      memcpy(this->buffer_ + ((y + y_start) * this->width_ + x_start) * 2,
+             ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2);
+    }
+    ptr = this->buffer_;
+    w = this->width_;
+    h += y_start;
+    x_start = 0;
+    y_start = 0;
+    x_offset = 0;
+    y_offset = 0;
   }
+  this->write_to_display_(x_start, y_start, w, h, ptr, x_offset, y_offset, x_pad);
+}
+
+void QspiDbi::write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
+                                int x_pad) {
   this->set_addr_window_(x_start, y_start, x_start + w - 1, y_start + h - 1);
   this->enable();
   // x_ and y_offset are offsets into the source buffer, unrelated to our own offsets into the display.
@@ -158,17 +174,50 @@ void QspiAmoLed::draw_pixels_at(int x_start, int y_start, int w, int h, const ui
     // we could deal here with a non-zero y_offset, but if x_offset is zero, y_offset probably will be so don't bother
     this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, ptr, w * h * 2, 4);
   } else {
-    this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, nullptr, 0, 4);
     auto stride = x_offset + w + x_pad;
+    uint16_t cmd = 0x2C00;
     for (int y = 0; y != h; y++) {
-      this->write_cmd_addr_data(0, 0, 0, 0, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
+      this->write_cmd_addr_data(8, 0x32, 24, cmd, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
+      cmd = 0x3C00;
     }
   }
   this->disable();
 }
+void QspiDbi::write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
+  ESP_LOGV(TAG, "Command %02X, length %d, bytes %s", cmd, len, format_hex_pretty(bytes, len).c_str());
+  this->enable();
+  this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
+  this->disable();
+}
+
+void QspiDbi::write_sequence_(const std::vector<uint8_t> &vec) {
+  size_t index = 0;
+  while (index != vec.size()) {
+    if (vec.size() - index < 2) {
+      ESP_LOGE(TAG, "Malformed init sequence");
+      return;
+    }
+    uint8_t cmd = vec[index++];
+    uint8_t x = vec[index++];
+    if (x == DELAY_FLAG) {
+      ESP_LOGV(TAG, "Delay %dms", cmd);
+      delay(cmd);
+    } else {
+      uint8_t num_args = x & 0x7F;
+      if (vec.size() - index < num_args) {
+        ESP_LOGE(TAG, "Malformed init sequence");
+        return;
+      }
+      const auto *ptr = vec.data() + index;
+      this->write_command_(cmd, ptr, num_args);
+      index += num_args;
+    }
+  }
+}
 
-void QspiAmoLed::dump_config() {
-  ESP_LOGCONFIG("", "QSPI AMOLED");
+void QspiDbi::dump_config() {
+  ESP_LOGCONFIG("", "QSPI_DBI Display");
+  ESP_LOGCONFIG("", "Model: %s", this->model_);
   ESP_LOGCONFIG(TAG, "  Height: %u", this->height_);
   ESP_LOGCONFIG(TAG, "  Width: %u", this->width_);
   LOG_PIN("  CS Pin: ", this->cs_);
@@ -176,6 +225,6 @@ void QspiAmoLed::dump_config() {
   ESP_LOGCONFIG(TAG, "  SPI Data rate: %dMHz", (unsigned) (this->data_rate_ / 1000000));
 }
 
-}  // namespace qspi_amoled
+}  // namespace qspi_dbi
 }  // namespace esphome
 #endif

esphome/components/{qspi_amoled/qspi_amoled.h → qspi_dbi/qspi_dbi.h}

@@ -14,11 +14,12 @@
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome {
-namespace qspi_amoled {
+namespace qspi_dbi {
 
-constexpr static const char *const TAG = "display.qspi_amoled";
+constexpr static const char *const TAG = "display.qspi_dbi";
 static const uint8_t SW_RESET_CMD = 0x01;
 static const uint8_t SLEEP_OUT = 0x11;
+static const uint8_t NORON = 0x13;
 static const uint8_t INVERT_OFF = 0x20;
 static const uint8_t INVERT_ON = 0x21;
 static const uint8_t ALL_ON = 0x23;
@@ -42,6 +43,7 @@ static const uint8_t MADCTL_MV = 0x20;   ///< Bit 5 Reverse Mode
 static const uint8_t MADCTL_RGB = 0x00;  ///< Bit 3 Red-Green-Blue pixel order
 static const uint8_t MADCTL_BGR = 0x08;  ///< Bit 3 Blue-Green-Red pixel order
 
+static const uint8_t DELAY_FLAG = 0xFF;
 // store a 16 bit value in a buffer, big endian.
 static inline void put16_be(uint8_t *buf, uint16_t value) {
   buf[0] = value >> 8;
@@ -49,15 +51,16 @@ static inline void put16_be(uint8_t *buf, uint16_t value) {
 }
 
 enum Model {
+  CUSTOM,
   RM690B0,
   RM67162,
 };
 
-class QspiAmoLed : public display::DisplayBuffer,
-                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
-                                         spi::DATA_RATE_1MHZ> {
+class QspiDbi : public display::DisplayBuffer,
+                public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
+                                      spi::DATA_RATE_1MHZ> {
  public:
-  void set_model(Model model) { this->model_ = model; }
+  void set_model(const char *model) { this->model_ = model; }
   void update() override;
   void setup() override;
   display::ColorOrder get_color_mode() { return this->color_mode_; }
@@ -93,17 +96,27 @@ class QspiAmoLed : public display::DisplayBuffer,
     this->offset_x_ = offset_x;
     this->offset_y_ = offset_y;
   }
+
+  void set_draw_from_origin(bool draw_from_origin) { this->draw_from_origin_ = draw_from_origin; }
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
   void dump_config() override;
 
   int get_width_internal() override { return this->width_; }
   int get_height_internal() override { return this->height_; }
   bool can_proceed() override { return this->setup_complete_; }
+  void add_init_sequence(const std::vector<uint8_t> &sequence) { this->init_sequences_.push_back(sequence); }
 
  protected:
+  void check_buffer_() {
+    if (this->buffer_ == nullptr)
+      this->init_internal_(this->width_ * this->height_ * 2);
+  }
+  void write_sequence_(const std::vector<uint8_t> &vec);
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
+  void write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
+                         int x_pad);
   /**
    * the RM67162 in quad SPI mode seems to work like this (not in the datasheet, this is deduced from the
    * sample code.)
@@ -122,11 +135,7 @@ class QspiAmoLed : public display::DisplayBuffer,
    * @param bytes
    * @param len
    */
-  void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
-    this->enable();
-    this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
-    this->disable();
-  }
+  void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len);
 
   void write_command_(uint8_t cmd, uint8_t data) { this->write_command_(cmd, &data, 1); }
   void write_command_(uint8_t cmd) { this->write_command_(cmd, &cmd, 0); }
@@ -136,8 +145,8 @@ class QspiAmoLed : public display::DisplayBuffer,
 
   GPIOPin *reset_pin_{nullptr};
   GPIOPin *enable_pin_{nullptr};
-  uint16_t x_low_{0};
-  uint16_t y_low_{0};
+  uint16_t x_low_{1};
+  uint16_t y_low_{1};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
   bool setup_complete_{};
@@ -151,12 +160,14 @@ class QspiAmoLed : public display::DisplayBuffer,
   bool swap_xy_{};
   bool mirror_x_{};
   bool mirror_y_{};
+  bool draw_from_origin_{false};
   uint8_t brightness_{0xD0};
-  Model model_{RM690B0};
+  const char *model_{"Unknown"};
+  std::vector<std::vector<uint8_t>> init_sequences_{};
 
   esp_lcd_panel_handle_t handle_{};
 };
 
-}  // namespace qspi_amoled
+}  // namespace qspi_dbi
 }  // namespace esphome
 #endif

esphome/components/rp2040/__init__.py

@@ -17,7 +17,7 @@ from esphome.const import (
     PLATFORM_RP2040,
 )
 from esphome.core import CORE, EsphomeError, coroutine_with_priority
-from esphome.helpers import copy_file_if_changed, mkdir_p, write_file
+from esphome.helpers import copy_file_if_changed, mkdir_p, write_file, read_file
 
 from .const import KEY_BOARD, KEY_PIO_FILES, KEY_RP2040, rp2040_ns
 
@@ -230,11 +230,14 @@ def generate_pio_files() -> bool:
 
 
 # Called by writer.py
-def copy_files() -> bool:
+def copy_files():
     dir = os.path.dirname(__file__)
     post_build_file = os.path.join(dir, "post_build.py.script")
     copy_file_if_changed(
         post_build_file,
         CORE.relative_build_path("post_build.py"),
     )
-    return generate_pio_files()
+    if generate_pio_files():
+        path = CORE.relative_src_path("esphome.h")
+        content = read_file(path).rstrip("\n")
+        write_file(path, content + '\n#include "pio_includes.h"\n')

esphome/components/rp2040/gpio.py

@@ -1,6 +1,8 @@
+from esphome import pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ANALOG,
     CONF_ID,
     CONF_INPUT,
     CONF_INVERTED,
@@ -10,10 +12,8 @@ from esphome.const import (
     CONF_OUTPUT,
     CONF_PULLDOWN,
     CONF_PULLUP,
-    CONF_ANALOG,
 )
 from esphome.core import CORE
-from esphome import pins
 
 from . import boards
 from .const import KEY_BOARD, KEY_RP2040, rp2040_ns
@@ -41,8 +41,10 @@ def _translate_pin(value):
             "This variable only supports pin numbers, not full pin schemas "
             "(with inverted and mode)."
         )
-    if isinstance(value, int):
+    if isinstance(value, int) and not isinstance(value, bool):
         return value
+    if not isinstance(value, str):
+        raise cv.Invalid(f"Invalid pin number: {value}")
     try:
         return int(value)
     except ValueError:

esphome/components/rtttl/rtttl.cpp

@@ -26,7 +26,10 @@ inline double deg2rad(double degrees) {
   return degrees * PI_ON_180;
 }
 
-void Rtttl::dump_config() { ESP_LOGCONFIG(TAG, "Rtttl"); }
+void Rtttl::dump_config() {
+  ESP_LOGCONFIG(TAG, "Rtttl:");
+  ESP_LOGCONFIG(TAG, "  Gain: %f", gain_);
+}
 
 void Rtttl::play(std::string rtttl) {
   if (this->state_ != State::STATE_STOPPED && this->state_ != State::STATE_STOPPING) {

esphome/components/rtttl/rtttl.h

@@ -39,6 +39,7 @@ class Rtttl : public Component {
 #ifdef USE_SPEAKER
   void set_speaker(speaker::Speaker *speaker) { this->speaker_ = speaker; }
 #endif
+  float get_gain() { return gain_; }
   void set_gain(float gain) {
     if (gain < 0.1f)
       gain = 0.1f;

esphome/components/sdl/sdl_esphome.cpp

@@ -9,8 +9,9 @@ void Sdl::setup() {
   ESP_LOGD(TAG, "Starting setup");
   SDL_Init(SDL_INIT_VIDEO);
   this->window_ = SDL_CreateWindow(App.get_name().c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-                                   this->width_, this->height_, 0);
+                                   this->width_, this->height_, SDL_WINDOW_RESIZABLE);
   this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
+  SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
   this->texture_ =
       SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
   SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
@@ -25,6 +26,10 @@ void Sdl::update() {
   this->y_low_ = this->height_;
   this->x_high_ = 0;
   this->y_high_ = 0;
+  this->redraw_(rect);
+}
+
+void Sdl::redraw_(SDL_Rect &rect) {
   SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
   SDL_RenderPresent(this->renderer_);
 }
@@ -33,15 +38,13 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
                          display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
   SDL_Rect rect{x_start, y_start, w, h};
   if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || big_endian) {
-    display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
-                                     x_pad);
+    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
   } else {
     auto stride = x_offset + w + x_pad;
     auto data = ptr + (stride * y_offset + x_offset) * 2;
     SDL_UpdateTexture(this->texture_, &rect, data, stride * 2);
   }
-  SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
-  SDL_RenderPresent(this->renderer_);
+  this->redraw_(rect);
 }
 
 void Sdl::draw_pixel_at(int x, int y, Color color) {
@@ -84,6 +87,20 @@ void Sdl::loop() {
         }
         break;
 
+      case SDL_WINDOWEVENT:
+        switch (e.window.event) {
+          case SDL_WINDOWEVENT_SIZE_CHANGED:
+          case SDL_WINDOWEVENT_EXPOSED:
+          case SDL_WINDOWEVENT_RESIZED: {
+            SDL_Rect rect{0, 0, this->width_, this->height_};
+            this->redraw_(rect);
+            break;
+          }
+          default:
+            break;
+        }
+        break;
+
       default:
         ESP_LOGV(TAG, "Event %d", e.type);
         break;

esphome/components/sdl/sdl_esphome.h

@@ -38,6 +38,7 @@ class Sdl : public display::Display {
  protected:
   int get_width_internal() override { return this->width_; }
   int get_height_internal() override { return this->height_; }
+  void redraw_(SDL_Rect &rect);
   int width_{};
   int height_{};
   SDL_Renderer *renderer_{};

esphome/components/sensor/__init__.py

@@ -335,19 +335,28 @@ def sensor_schema(
     return SENSOR_SCHEMA.extend(schema)
 
 
-@FILTER_REGISTRY.register("offset", OffsetFilter, cv.float_)
+@FILTER_REGISTRY.register("offset", OffsetFilter, cv.templatable(cv.float_))
 async def offset_filter_to_code(config, filter_id):
-    return cg.new_Pvariable(filter_id, config)
+    template_ = await cg.templatable(config, [], float)
+    return cg.new_Pvariable(filter_id, template_)
 
 
-@FILTER_REGISTRY.register("multiply", MultiplyFilter, cv.float_)
+@FILTER_REGISTRY.register("multiply", MultiplyFilter, cv.templatable(cv.float_))
 async def multiply_filter_to_code(config, filter_id):
-    return cg.new_Pvariable(filter_id, config)
+    template_ = await cg.templatable(config, [], float)
+    return cg.new_Pvariable(filter_id, template_)
 
 
-@FILTER_REGISTRY.register("filter_out", FilterOutValueFilter, cv.float_)
+@FILTER_REGISTRY.register(
+    "filter_out",
+    FilterOutValueFilter,
+    cv.Any(cv.templatable(cv.float_), [cv.templatable(cv.float_)]),
+)
 async def filter_out_filter_to_code(config, filter_id):
-    return cg.new_Pvariable(filter_id, config)
+    if not isinstance(config, list):
+        config = [config]
+    template_ = [await cg.templatable(x, [], float) for x in config]
+    return cg.new_Pvariable(filter_id, template_)
 
 
 QUANTILE_SCHEMA = cv.All(
@@ -573,7 +582,7 @@ async def heartbeat_filter_to_code(config, filter_id):
 TIMEOUT_SCHEMA = cv.maybe_simple_value(
     {
         cv.Required(CONF_TIMEOUT): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_VALUE, default="nan"): cv.float_,
+        cv.Optional(CONF_VALUE, default="nan"): cv.templatable(cv.float_),
     },
     key=CONF_TIMEOUT,
 )
@@ -581,7 +590,8 @@ TIMEOUT_SCHEMA = cv.maybe_simple_value(
 
 @FILTER_REGISTRY.register("timeout", TimeoutFilter, TIMEOUT_SCHEMA)
 async def timeout_filter_to_code(config, filter_id):
-    var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], config[CONF_VALUE])
+    template_ = await cg.templatable(config[CONF_VALUE], [], float)
+    var = cg.new_Pvariable(filter_id, config[CONF_TIMEOUT], template_)
     await cg.register_component(var, {})
     return var
 

esphome/components/sensor/filter.cpp

@@ -288,36 +288,36 @@ optional<float> LambdaFilter::new_value(float value) {
 }
 
 // OffsetFilter
-OffsetFilter::OffsetFilter(float offset) : offset_(offset) {}
+OffsetFilter::OffsetFilter(TemplatableValue<float> offset) : offset_(std::move(offset)) {}
 
-optional<float> OffsetFilter::new_value(float value) { return value + this->offset_; }
+optional<float> OffsetFilter::new_value(float value) { return value + this->offset_.value(); }
 
 // MultiplyFilter
-MultiplyFilter::MultiplyFilter(float multiplier) : multiplier_(multiplier) {}
+MultiplyFilter::MultiplyFilter(TemplatableValue<float> multiplier) : multiplier_(std::move(multiplier)) {}
 
-optional<float> MultiplyFilter::new_value(float value) { return value * this->multiplier_; }
+optional<float> MultiplyFilter::new_value(float value) { return value * this->multiplier_.value(); }
 
 // FilterOutValueFilter
-FilterOutValueFilter::FilterOutValueFilter(float value_to_filter_out) : value_to_filter_out_(value_to_filter_out) {}
+FilterOutValueFilter::FilterOutValueFilter(std::vector<TemplatableValue<float>> values_to_filter_out)
+    : values_to_filter_out_(std::move(values_to_filter_out)) {}
 
 optional<float> FilterOutValueFilter::new_value(float value) {
-  if (std::isnan(this->value_to_filter_out_)) {
-    if (std::isnan(value)) {
-      return {};
-    } else {
-      return value;
+  int8_t accuracy = this->parent_->get_accuracy_decimals();
+  float accuracy_mult = powf(10.0f, accuracy);
+  for (auto filter_value : this->values_to_filter_out_) {
+    if (std::isnan(filter_value.value())) {
+      if (std::isnan(value)) {
+        return {};
+      }
+      continue;
     }
-  } else {
-    int8_t accuracy = this->parent_->get_accuracy_decimals();
-    float accuracy_mult = powf(10.0f, accuracy);
-    float rounded_filter_out = roundf(accuracy_mult * this->value_to_filter_out_);
+    float rounded_filter_out = roundf(accuracy_mult * filter_value.value());
     float rounded_value = roundf(accuracy_mult * value);
     if (rounded_filter_out == rounded_value) {
       return {};
-    } else {
-      return value;
     }
   }
+  return value;
 }
 
 // ThrottleFilter
@@ -383,11 +383,12 @@ void OrFilter::initialize(Sensor *parent, Filter *next) {
 
 // TimeoutFilter
 optional<float> TimeoutFilter::new_value(float value) {
-  this->set_timeout("timeout", this->time_period_, [this]() { this->output(this->value_); });
+  this->set_timeout("timeout", this->time_period_, [this]() { this->output(this->value_.value()); });
   return value;
 }
 
-TimeoutFilter::TimeoutFilter(uint32_t time_period, float new_value) : time_period_(time_period), value_(new_value) {}
+TimeoutFilter::TimeoutFilter(uint32_t time_period, TemplatableValue<float> new_value)
+    : time_period_(time_period), value_(std::move(new_value)) {}
 float TimeoutFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 // DebounceFilter