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

esphome/components/font/__init__.py

@@ -1,6 +1,7 @@
 from collections.abc import MutableMapping
 import functools
 import hashlib
+from itertools import accumulate
 import logging
 import os
 from pathlib import Path
@@ -468,8 +469,9 @@ class EFont:
 
 
 class GlyphInfo:
-    def __init__(self, data_len, advance, offset_x, offset_y, width, height):
-        self.data_len = data_len
+    def __init__(self, glyph, data, advance, offset_x, offset_y, width, height):
+        self.glyph = glyph
+        self.bitmap_data = data
         self.advance = advance
         self.offset_x = offset_x
         self.offset_y = offset_y
@@ -477,6 +479,62 @@ class GlyphInfo:
         self.height = height
 
 
+def glyph_to_glyphinfo(glyph, font, size, bpp):
+    scale = 256 // (1 << bpp)
+    if not font.is_scalable:
+        sizes = [pt_to_px(x.size) for x in font.available_sizes]
+        if size in sizes:
+            font.select_size(sizes.index(size))
+    else:
+        font.set_pixel_sizes(size, 0)
+    flags = FT_LOAD_RENDER
+    if bpp != 1:
+        flags |= FT_LOAD_NO_BITMAP
+    else:
+        flags |= FT_LOAD_TARGET_MONO
+    font.load_char(glyph, flags)
+    width = font.glyph.bitmap.width
+    height = font.glyph.bitmap.rows
+    buffer = font.glyph.bitmap.buffer
+    pitch = font.glyph.bitmap.pitch
+    glyph_data = [0] * ((height * width * bpp + 7) // 8)
+    src_mode = font.glyph.bitmap.pixel_mode
+    pos = 0
+    for y in range(height):
+        for x in range(width):
+            if src_mode == ft_pixel_mode_mono:
+                pixel = (
+                    (1 << bpp) - 1
+                    if buffer[y * pitch + x // 8] & (1 << (7 - x % 8))
+                    else 0
+                )
+            else:
+                pixel = buffer[y * pitch + x] // scale
+            for bit_num in range(bpp):
+                if pixel & (1 << (bpp - bit_num - 1)):
+                    glyph_data[pos // 8] |= 0x80 >> (pos % 8)
+                pos += 1
+    ascender = pt_to_px(font.size.ascender)
+    if ascender == 0:
+        if not font.is_scalable:
+            ascender = size
+        else:
+            _LOGGER.error(
+                "Unable to determine ascender of font %s %s",
+                font.family_name,
+                font.style_name,
+            )
+    return GlyphInfo(
+        glyph,
+        glyph_data,
+        pt_to_px(font.glyph.metrics.horiAdvance),
+        font.glyph.bitmap_left,
+        ascender - font.glyph.bitmap_top,
+        width,
+        height,
+    )
+
+
 async def to_code(config):
     """
     Collect all glyph codepoints, construct a map from a codepoint to a font file.
@@ -506,98 +564,47 @@ async def to_code(config):
 
     codepoints = list(point_set)
     codepoints.sort(key=functools.cmp_to_key(glyph_comparator))
-    glyph_args = {}
-    data = []
     bpp = config[CONF_BPP]
-    scale = 256 // (1 << bpp)
     size = config[CONF_SIZE]
     # create the data array for all glyphs
-    for codepoint in codepoints:
-        font = point_font_map[codepoint]
-        if not font.is_scalable:
-            sizes = [pt_to_px(x.size) for x in font.available_sizes]
-            if size in sizes:
-                font.select_size(sizes.index(size))
-        else:
-            font.set_pixel_sizes(size, 0)
-        flags = FT_LOAD_RENDER
-        if bpp != 1:
-            flags |= FT_LOAD_NO_BITMAP
-        else:
-            flags |= FT_LOAD_TARGET_MONO
-        font.load_char(codepoint, flags)
-        width = font.glyph.bitmap.width
-        height = font.glyph.bitmap.rows
-        buffer = font.glyph.bitmap.buffer
-        pitch = font.glyph.bitmap.pitch
-        glyph_data = [0] * ((height * width * bpp + 7) // 8)
-        src_mode = font.glyph.bitmap.pixel_mode
-        pos = 0
-        for y in range(height):
-            for x in range(width):
-                if src_mode == ft_pixel_mode_mono:
-                    pixel = (
-                        (1 << bpp) - 1
-                        if buffer[y * pitch + x // 8] & (1 << (7 - x % 8))
-                        else 0
-                    )
-                else:
-                    pixel = buffer[y * pitch + x] // scale
-                for bit_num in range(bpp):
-                    if pixel & (1 << (bpp - bit_num - 1)):
-                        glyph_data[pos // 8] |= 0x80 >> (pos % 8)
-                    pos += 1
-        ascender = pt_to_px(font.size.ascender)
-        if ascender == 0:
-            if not font.is_scalable:
-                ascender = size
-            else:
-                _LOGGER.error(
-                    "Unable to determine ascender of font %s", config[CONF_FILE]
-                )
-        glyph_args[codepoint] = GlyphInfo(
-            len(data),
-            pt_to_px(font.glyph.metrics.horiAdvance),
-            font.glyph.bitmap_left,
-            ascender - font.glyph.bitmap_top,
-            width,
-            height,
-        )
-        data += glyph_data
-
-    rhs = [HexInt(x) for x in data]
+    glyph_args = [
+        glyph_to_glyphinfo(x, point_font_map[x], size, bpp) for x in codepoints
+    ]
+    rhs = [HexInt(x) for x in flatten([x.bitmap_data for x in glyph_args])]
     prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
 
     # Create the glyph table that points to data in the above array.
-    glyph_initializer = []
-    for codepoint in codepoints:
-        glyph_initializer.append(
-            cg.StructInitializer(
-                GlyphData,
-                (
-                    "a_char",
-                    cg.RawExpression(
-                        f"(const uint8_t *){cpp_string_escape(codepoint)}"
-                    ),
-                ),
-                (
-                    "data",
-                    cg.RawExpression(
-                        f"{str(prog_arr)} + {str(glyph_args[codepoint].data_len)}"
-                    ),
-                ),
-                ("advance", glyph_args[codepoint].advance),
-                ("offset_x", glyph_args[codepoint].offset_x),
-                ("offset_y", glyph_args[codepoint].offset_y),
-                ("width", glyph_args[codepoint].width),
-                ("height", glyph_args[codepoint].height),
-            )
+    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),
+        )
+        for (x, y) in zip(
+            glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )
+    ]
 
     glyphs = cg.static_const_array(config[CONF_RAW_GLYPH_ID], glyph_initializer)
 
     font_height = pt_to_px(base_font.size.height)
     ascender = pt_to_px(base_font.size.ascender)
+    descender = abs(pt_to_px(base_font.size.descender))
+    g = glyph_to_glyphinfo("x", base_font, size, bpp)
+    xheight = g.height if len(g.bitmap_data) > 1 else 0
+    g = glyph_to_glyphinfo("X", base_font, size, bpp)
+    capheight = g.height if len(g.bitmap_data) > 1 else 0
     if font_height == 0:
         if not base_font.is_scalable:
             font_height = size
@@ -610,5 +617,8 @@ async def to_code(config):
         len(glyph_initializer),
         ascender,
         font_height,
+        descender,
+        xheight,
+        capheight,
         bpp,
     )

esphome/components/font/font.cpp

@@ -45,8 +45,15 @@ void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
   *height = this->glyph_data_->height;
 }
 
-Font::Font(const GlyphData *data, int data_nr, int baseline, int height, uint8_t bpp)
-    : baseline_(baseline), height_(height), bpp_(bpp) {
+Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+           uint8_t bpp)
+    : 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]);

esphome/components/font/font.h

@@ -50,11 +50,17 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param glyphs A vector of glyphs, must be sorted lexicographically.
+   * @param data A vector of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs in data.
    * @param baseline The y-offset from the top of the text to the baseline.
-   * @param bottom The y-offset from the top of the text to the bottom (i.e. height).
+   * @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).
+   * @param xheight The height of lowercase letters, usually measured at the "x" glyph.
+   * @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, uint8_t bpp = 1);
+  Font(const GlyphData *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);
 
@@ -65,14 +71,23 @@ class Font
 #endif
   inline int get_baseline() { return this->baseline_; }
   inline int get_height() { return this->height_; }
+  inline int get_ascender() { return this->baseline_; }
+  inline int get_descender() { return this->descender_; }
+  inline int get_linegap() { return this->linegap_; }
+  inline int get_xheight() { return this->xheight_; }
+  inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
 
-  const std::vector<Glyph, ExternalRAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
+  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
 
  protected:
-  std::vector<Glyph, ExternalRAMAllocator<Glyph>> glyphs_;
+  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
   int baseline_;
   int height_;
+  int descender_;
+  int linegap_;
+  int xheight_;
+  int capheight_;
   uint8_t bpp_;  // bits per pixel
 };
 

esphome/components/fs3000/fs3000.h

@@ -18,7 +18,6 @@ class FS3000Component : public PollingComponent, public i2c::I2CDevice, public s
   void update() override;
 
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_model(FS3000Model model) { this->model_ = model; }
 

esphome/components/gcja5/gcja5.h

@@ -12,7 +12,6 @@ class GCJA5Component : public Component, public uart::UARTDevice {
  public:
   void dump_config() override;
   void loop() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_pm_1_0_sensor(sensor::Sensor *pm_1_0) { pm_1_0_sensor_ = pm_1_0; }
   void set_pm_2_5_sensor(sensor::Sensor *pm_2_5) { pm_2_5_sensor_ = pm_2_5; }

esphome/components/gl_r01_i2c/gl_r01_i2c.cpp

@@ -0,0 +1,68 @@
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include "gl_r01_i2c.h"
+
+namespace esphome {
+namespace gl_r01_i2c {
+
+static const char *const TAG = "gl_r01_i2c";
+
+// Register definitions from datasheet
+static const uint8_t REG_VERSION = 0x00;
+static const uint8_t REG_DISTANCE = 0x02;
+static const uint8_t REG_TRIGGER = 0x10;
+static const uint8_t CMD_TRIGGER = 0xB0;
+static const uint8_t RESTART_CMD1 = 0x5A;
+static const uint8_t RESTART_CMD2 = 0xA5;
+static const uint8_t READ_DELAY = 40;  // minimum milliseconds from datasheet to safely read measurement result
+
+void GLR01I2CComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up GL-R01 I2C...");
+  // Verify sensor presence
+  if (!this->read_byte_16(REG_VERSION, &this->version_)) {
+    ESP_LOGE(TAG, "Failed to communicate with GL-R01 I2C sensor!");
+    this->mark_failed();
+    return;
+  }
+  ESP_LOGD(TAG, "Found GL-R01 I2C with version 0x%04X", this->version_);
+}
+
+void GLR01I2CComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "GL-R01 I2C:");
+  ESP_LOGCONFIG(TAG, " Firmware Version: 0x%04X", this->version_);
+  LOG_I2C_DEVICE(this);
+  LOG_SENSOR(" ", "Distance", this);
+}
+
+void GLR01I2CComponent::update() {
+  // Trigger a new measurement
+  if (!this->write_byte(REG_TRIGGER, CMD_TRIGGER)) {
+    ESP_LOGE(TAG, "Failed to trigger measurement!");
+    this->status_set_warning();
+    return;
+  }
+
+  // Schedule reading the result after the read delay
+  this->set_timeout(READ_DELAY, [this]() { this->read_distance_(); });
+}
+
+void GLR01I2CComponent::read_distance_() {
+  uint16_t distance = 0;
+  if (!this->read_byte_16(REG_DISTANCE, &distance)) {
+    ESP_LOGE(TAG, "Failed to read distance value!");
+    this->status_set_warning();
+    return;
+  }
+
+  if (distance == 0xFFFF) {
+    ESP_LOGW(TAG, "Invalid measurement received!");
+    this->status_set_warning();
+  } else {
+    ESP_LOGV(TAG, "Distance: %umm", distance);
+    this->publish_state(distance);
+    this->status_clear_warning();
+  }
+}
+
+}  // namespace gl_r01_i2c
+}  // namespace esphome

esphome/components/gl_r01_i2c/gl_r01_i2c.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace gl_r01_i2c {
+
+class GLR01I2CComponent : public sensor::Sensor, public i2c::I2CDevice, public PollingComponent {
+ public:
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+
+ protected:
+  void read_distance_();
+  uint16_t version_{0};
+};
+
+}  // namespace gl_r01_i2c
+}  // namespace esphome

esphome/components/gl_r01_i2c/sensor.py

@@ -0,0 +1,36 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_DISTANCE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_MILLIMETER,
+)
+
+CODEOWNERS = ["@pkejval"]
+DEPENDENCIES = ["i2c"]
+
+gl_r01_i2c_ns = cg.esphome_ns.namespace("gl_r01_i2c")
+GLR01I2CComponent = gl_r01_i2c_ns.class_(
+    "GLR01I2CComponent", i2c.I2CDevice, cg.PollingComponent
+)
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        GLR01I2CComponent,
+        unit_of_measurement=UNIT_MILLIMETER,
+        accuracy_decimals=0,
+        device_class=DEVICE_CLASS_DISTANCE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x74))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/gp8403/gp8403.h

@@ -15,7 +15,6 @@ class GP8403 : public Component, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_voltage(gp8403::GP8403Voltage voltage) { this->voltage_ = voltage; }
 

esphome/components/gpio/binary_sensor/__init__.py

@@ -10,11 +10,24 @@ GPIOBinarySensor = gpio_ns.class_(
     "GPIOBinarySensor", binary_sensor.BinarySensor, cg.Component
 )
 
+CONF_USE_INTERRUPT = "use_interrupt"
+CONF_INTERRUPT_TYPE = "interrupt_type"
+
+INTERRUPT_TYPES = {
+    "RISING": gpio_ns.INTERRUPT_RISING_EDGE,
+    "FALLING": gpio_ns.INTERRUPT_FALLING_EDGE,
+    "ANY": gpio_ns.INTERRUPT_ANY_EDGE,
+}
+
 CONFIG_SCHEMA = (
     binary_sensor.binary_sensor_schema(GPIOBinarySensor)
     .extend(
         {
             cv.Required(CONF_PIN): pins.gpio_input_pin_schema,
+            cv.Optional(CONF_USE_INTERRUPT, default=True): cv.boolean,
+            cv.Optional(CONF_INTERRUPT_TYPE, default="ANY"): cv.enum(
+                INTERRUPT_TYPES, upper=True
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -27,3 +40,7 @@ async def to_code(config):
 
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     cg.add(var.set_pin(pin))
+
+    cg.add(var.set_use_interrupt(config[CONF_USE_INTERRUPT]))
+    if config[CONF_USE_INTERRUPT]:
+        cg.add(var.set_interrupt_type(config[CONF_INTERRUPT_TYPE]))

esphome/components/gpio/binary_sensor/gpio_binary_sensor.cpp

@@ -6,17 +6,91 @@ namespace gpio {
 
 static const char *const TAG = "gpio.binary_sensor";
 
+void IRAM_ATTR GPIOBinarySensorStore::gpio_intr(GPIOBinarySensorStore *arg) {
+  bool new_state = arg->isr_pin_.digital_read();
+  if (new_state != arg->last_state_) {
+    arg->state_ = new_state;
+    arg->last_state_ = new_state;
+    arg->changed_ = true;
+    // Wake up the component from its disabled loop state
+    if (arg->component_ != nullptr) {
+      arg->component_->enable_loop_soon_any_context();
+    }
+  }
+}
+
+void GPIOBinarySensorStore::setup(InternalGPIOPin *pin, gpio::InterruptType type, Component *component) {
+  pin->setup();
+  this->isr_pin_ = pin->to_isr();
+  this->component_ = component;
+
+  // Read initial state
+  this->last_state_ = pin->digital_read();
+  this->state_ = this->last_state_;
+
+  // Attach interrupt - from this point on, any changes will be caught by the interrupt
+  pin->attach_interrupt(&GPIOBinarySensorStore::gpio_intr, this, type);
+}
+
 void GPIOBinarySensor::setup() {
-  this->pin_->setup();
-  this->publish_initial_state(this->pin_->digital_read());
+  if (this->use_interrupt_ && !this->pin_->is_internal()) {
+    ESP_LOGD(TAG, "GPIO is not internal, falling back to polling mode");
+    this->use_interrupt_ = false;
+  }
+
+  if (this->use_interrupt_) {
+    auto *internal_pin = static_cast<InternalGPIOPin *>(this->pin_);
+    this->store_.setup(internal_pin, this->interrupt_type_, this);
+    this->publish_initial_state(this->store_.get_state());
+  } else {
+    this->pin_->setup();
+    this->publish_initial_state(this->pin_->digital_read());
+  }
 }
 
 void GPIOBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "GPIO Binary Sensor", this);
   LOG_PIN("  Pin: ", this->pin_);
+  const char *mode = this->use_interrupt_ ? "interrupt" : "polling";
+  ESP_LOGCONFIG(TAG, "  Mode: %s", mode);
+  if (this->use_interrupt_) {
+    const char *interrupt_type;
+    switch (this->interrupt_type_) {
+      case gpio::INTERRUPT_RISING_EDGE:
+        interrupt_type = "RISING_EDGE";
+        break;
+      case gpio::INTERRUPT_FALLING_EDGE:
+        interrupt_type = "FALLING_EDGE";
+        break;
+      case gpio::INTERRUPT_ANY_EDGE:
+        interrupt_type = "ANY_EDGE";
+        break;
+      default:
+        interrupt_type = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Interrupt Type: %s", interrupt_type);
+  }
 }
 
-void GPIOBinarySensor::loop() { this->publish_state(this->pin_->digital_read()); }
+void GPIOBinarySensor::loop() {
+  if (this->use_interrupt_) {
+    if (this->store_.is_changed()) {
+      // Clear the flag immediately to minimize the window where we might miss changes
+      this->store_.clear_changed();
+      // Read the state and publish it
+      // Note: If the ISR fires between clear_changed() and get_state(), that's fine -
+      // we'll process the new change on the next loop iteration
+      bool state = this->store_.get_state();
+      this->publish_state(state);
+    } else {
+      // No changes, disable the loop until the next interrupt
+      this->disable_loop();
+    }
+  } else {
+    this->publish_state(this->pin_->digital_read());
+  }
+}
 
 float GPIOBinarySensor::get_setup_priority() const { return setup_priority::HARDWARE; }
 

esphome/components/gpio/binary_sensor/gpio_binary_sensor.h

@@ -2,14 +2,51 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
 namespace esphome {
 namespace gpio {
 
+// Store class for ISR data (no vtables, ISR-safe)
+class GPIOBinarySensorStore {
+ public:
+  void setup(InternalGPIOPin *pin, gpio::InterruptType type, Component *component);
+
+  static void gpio_intr(GPIOBinarySensorStore *arg);
+
+  bool get_state() const {
+    // No lock needed: state_ is atomically updated by ISR
+    // Volatile ensures we read the latest value
+    return this->state_;
+  }
+
+  bool is_changed() const {
+    // Simple read of volatile bool - no clearing here
+    return this->changed_;
+  }
+
+  void clear_changed() {
+    // Separate method to clear the flag
+    this->changed_ = false;
+  }
+
+ protected:
+  ISRInternalGPIOPin isr_pin_;
+  volatile bool state_{false};
+  volatile bool last_state_{false};
+  volatile bool changed_{false};
+  Component *component_{nullptr};  // Pointer to the component for enable_loop_soon_any_context()
+};
+
 class GPIOBinarySensor : public binary_sensor::BinarySensor, public Component {
  public:
+  // No destructor needed: ESPHome components are created at boot and live forever.
+  // Interrupts are only detached on reboot when memory is cleared anyway.
+
   void set_pin(GPIOPin *pin) { pin_ = pin; }
+  void set_use_interrupt(bool use_interrupt) { use_interrupt_ = use_interrupt; }
+  void set_interrupt_type(gpio::InterruptType type) { interrupt_type_ = type; }
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
   /// Setup pin
@@ -22,6 +59,9 @@ class GPIOBinarySensor : public binary_sensor::BinarySensor, public Component {
 
  protected:
   GPIOPin *pin_;
+  bool use_interrupt_{true};
+  gpio::InterruptType interrupt_type_{gpio::INTERRUPT_ANY_EDGE};
+  GPIOBinarySensorStore store_;
 };
 
 }  // namespace gpio

esphome/components/grove_gas_mc_v2/grove_gas_mc_v2.h

@@ -22,8 +22,6 @@ class GroveGasMultichannelV2Component : public PollingComponent, public i2c::I2C
 
   void dump_config() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
  protected:
   enum ErrorCode {
     UNKNOWN,

esphome/components/he60r/he60r.h

@@ -13,7 +13,6 @@ class HE60rCover : public cover::Cover, public Component, public uart::UARTDevic
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; };
 
   void set_open_duration(uint32_t duration) { this->open_duration_ = duration; }
   void set_close_duration(uint32_t duration) { this->close_duration_ = duration; }

esphome/components/heatpumpir/climate.py

@@ -70,6 +70,7 @@ PROTOCOLS = {
     "airway": Protocol.PROTOCOL_AIRWAY,
     "bgh_aud": Protocol.PROTOCOL_BGH_AUD,
     "panasonic_altdke": Protocol.PROTOCOL_PANASONIC_ALTDKE,
+    "philco_phs32": Protocol.PROTOCOL_PHILCO_PHS32,
     "vaillantvai8": Protocol.PROTOCOL_VAILLANTVAI8,
     "r51m": Protocol.PROTOCOL_R51M,
 }
@@ -125,6 +126,6 @@ async def to_code(config):
     cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
     cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
 
-    cg.add_library("tonia/HeatpumpIR", "1.0.32")
+    cg.add_library("tonia/HeatpumpIR", "1.0.35")
     if CORE.is_libretiny:
         CORE.add_platformio_option("lib_ignore", "IRremoteESP8266")

esphome/components/heatpumpir/heatpumpir.cpp

@@ -65,6 +65,7 @@ const std::map<Protocol, std::function<HeatpumpIR *()>> PROTOCOL_CONSTRUCTOR_MAP
     {PROTOCOL_AIRWAY, []() { return new AIRWAYHeatpumpIR(); }},                              // NOLINT
     {PROTOCOL_BGH_AUD, []() { return new BGHHeatpumpIR(); }},                                // NOLINT
     {PROTOCOL_PANASONIC_ALTDKE, []() { return new PanasonicAltDKEHeatpumpIR(); }},           // NOLINT
+    {PROTOCOL_PHILCO_PHS32, []() { return new PhilcoPHS32HeatpumpIR(); }},                   // NOLINT
     {PROTOCOL_VAILLANTVAI8, []() { return new VaillantHeatpumpIR(); }},                      // NOLINT
     {PROTOCOL_R51M, []() { return new R51MHeatpumpIR(); }},                                  // NOLINT
 };