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

esphome/components/packet_transport/packet_transport.cpp

@@ -314,11 +314,43 @@ void PacketTransport::send_data_(bool all) {
 }
 
 void PacketTransport::update() {
+  if (!this->ping_pong_enable_) {
+    return;
+  }
   auto now = millis() / 1000;
   if (this->last_key_time_ + this->ping_pong_recyle_time_ < now) {
     this->resend_ping_key_ = this->ping_pong_enable_;
+    ESP_LOGV(TAG, "Ping request, age %u", now - this->last_key_time_);
     this->last_key_time_ = now;
   }
+  for (const auto &provider : this->providers_) {
+    uint32_t key_response_age = now - provider.second.last_key_response_time;
+    if (key_response_age > (this->ping_pong_recyle_time_ * 2u)) {
+#ifdef USE_STATUS_SENSOR
+      if (provider.second.status_sensor != nullptr && provider.second.status_sensor->state) {
+        ESP_LOGI(TAG, "Ping status for %s timeout at %u with age %u", provider.first.c_str(), now, key_response_age);
+        provider.second.status_sensor->publish_state(false);
+      }
+#endif
+#ifdef USE_SENSOR
+      for (auto &sensor : this->remote_sensors_[provider.first]) {
+        sensor.second->publish_state(NAN);
+      }
+#endif
+#ifdef USE_BINARY_SENSOR
+      for (auto &sensor : this->remote_binary_sensors_[provider.first]) {
+        sensor.second->invalidate_state();
+      }
+#endif
+    } else {
+#ifdef USE_STATUS_SENSOR
+      if (provider.second.status_sensor != nullptr && !provider.second.status_sensor->state) {
+        ESP_LOGI(TAG, "Ping status for %s restored at %u with age %u", provider.first.c_str(), now, key_response_age);
+        provider.second.status_sensor->publish_state(true);
+      }
+#endif
+    }
+  }
 }
 
 void PacketTransport::add_key_(const char *name, uint32_t key) {
@@ -437,7 +469,8 @@ void PacketTransport::process_(const std::vector<uint8_t> &data) {
     if (decoder.decode(PING_KEY, key) == DECODE_OK) {
       if (key == this->ping_key_) {
         ping_key_seen = true;
-        ESP_LOGV(TAG, "Found good ping key %X", (unsigned) key);
+        provider.last_key_response_time = millis() / 1000;
+        ESP_LOGV(TAG, "Found good ping key %X at timestamp %" PRIu32, (unsigned) key, provider.last_key_response_time);
       } else {
         ESP_LOGV(TAG, "Unknown ping key %X", (unsigned) key);
       }

esphome/components/packet_transport/packet_transport.h

@@ -8,7 +8,7 @@
 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
-#
+
 #include <vector>
 #include <map>
 
@@ -27,6 +27,10 @@ struct Provider {
   std::vector<uint8_t> encryption_key;
   const char *name;
   uint32_t last_code[2];
+  uint32_t last_key_response_time;
+#ifdef USE_STATUS_SENSOR
+  binary_sensor::BinarySensor *status_sensor{nullptr};
+#endif
 };
 
 #ifdef USE_SENSOR
@@ -75,10 +79,7 @@ class PacketTransport : public PollingComponent {
 
   void add_provider(const char *hostname) {
     if (this->providers_.count(hostname) == 0) {
-      Provider provider;
-      provider.encryption_key = std::vector<uint8_t>{};
-      provider.last_code[0] = 0;
-      provider.last_code[1] = 0;
+      Provider provider{};
       provider.name = hostname;
       this->providers_[hostname] = provider;
 #ifdef USE_SENSOR
@@ -97,6 +98,11 @@ class PacketTransport : public PollingComponent {
   void set_provider_encryption(const char *name, std::vector<uint8_t> key) {
     this->providers_[name].encryption_key = std::move(key);
   }
+#ifdef USE_STATUS_SENSOR
+  void set_provider_status_sensor(const char *name, binary_sensor::BinarySensor *sensor) {
+    this->providers_[name].status_sensor = sensor;
+  }
+#endif
   void set_platform_name(const char *name) { this->platform_name_ = name; }
 
  protected:

esphome/components/pcf8574/__init__.py

@@ -53,7 +53,7 @@ PCF8574_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=17),
     modes=[CONF_INPUT, CONF_OUTPUT],
     mode_validator=validate_mode,
-    invertable=True,
+    invertible=True,
 ).extend(
     {
         cv.Required(CONF_PCF8574): cv.use_id(PCF8574Component),

esphome/components/pi4ioe5v6408/__init__.py

@@ -0,0 +1,84 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import i2c
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_INPUT,
+    CONF_INVERTED,
+    CONF_MODE,
+    CONF_NUMBER,
+    CONF_OUTPUT,
+    CONF_PULLDOWN,
+    CONF_PULLUP,
+    CONF_RESET,
+)
+
+AUTO_LOAD = ["gpio_expander"]
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["i2c"]
+MULTI_CONF = True
+
+
+pi4ioe5v6408_ns = cg.esphome_ns.namespace("pi4ioe5v6408")
+PI4IOE5V6408Component = pi4ioe5v6408_ns.class_(
+    "PI4IOE5V6408Component", cg.Component, i2c.I2CDevice
+)
+PI4IOE5V6408GPIOPin = pi4ioe5v6408_ns.class_("PI4IOE5V6408GPIOPin", cg.GPIOPin)
+
+CONF_PI4IOE5V6408 = "pi4ioe5v6408"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.declare_id(PI4IOE5V6408Component),
+            cv.Optional(CONF_RESET, default=True): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x43))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    cg.add(var.set_reset(config[CONF_RESET]))
+
+
+def validate_mode(value):
+    if not (value[CONF_INPUT] or value[CONF_OUTPUT]):
+        raise cv.Invalid("Mode must be either input or output")
+    if value[CONF_INPUT] and value[CONF_OUTPUT]:
+        raise cv.Invalid("Mode must be either input or output")
+    return value
+
+
+PI4IOE5V6408_PIN_SCHEMA = pins.gpio_base_schema(
+    PI4IOE5V6408GPIOPin,
+    cv.int_range(min=0, max=7),
+    modes=[
+        CONF_INPUT,
+        CONF_OUTPUT,
+        CONF_PULLUP,
+        CONF_PULLDOWN,
+    ],
+    mode_validator=validate_mode,
+).extend(
+    {
+        cv.Required(CONF_PI4IOE5V6408): cv.use_id(PI4IOE5V6408Component),
+    }
+)
+
+
+@pins.PIN_SCHEMA_REGISTRY.register(CONF_PI4IOE5V6408, PI4IOE5V6408_PIN_SCHEMA)
+async def pi4ioe5v6408_pin_schema(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_parented(var, config[CONF_PI4IOE5V6408])
+
+    cg.add(var.set_pin(config[CONF_NUMBER]))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
+    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
+    return var

esphome/components/pi4ioe5v6408/pi4ioe5v6408.cpp

@@ -0,0 +1,171 @@
+#include "pi4ioe5v6408.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace pi4ioe5v6408 {
+
+static const uint8_t PI4IOE5V6408_REGISTER_DEVICE_ID = 0x01;
+static const uint8_t PI4IOE5V6408_REGISTER_IO_DIR = 0x03;
+static const uint8_t PI4IOE5V6408_REGISTER_OUT_SET = 0x05;
+static const uint8_t PI4IOE5V6408_REGISTER_OUT_HIGH_IMPEDENCE = 0x07;
+static const uint8_t PI4IOE5V6408_REGISTER_IN_DEFAULT_STATE = 0x09;
+static const uint8_t PI4IOE5V6408_REGISTER_PULL_ENABLE = 0x0B;
+static const uint8_t PI4IOE5V6408_REGISTER_PULL_SELECT = 0x0D;
+static const uint8_t PI4IOE5V6408_REGISTER_IN_STATE = 0x0F;
+static const uint8_t PI4IOE5V6408_REGISTER_INTERRUPT_ENABLE_MASK = 0x11;
+static const uint8_t PI4IOE5V6408_REGISTER_INTERRUPT_STATUS = 0x13;
+
+static const char *const TAG = "pi4ioe5v6408";
+
+void PI4IOE5V6408Component::setup() {
+  ESP_LOGCONFIG(TAG, "Running setup");
+  if (this->reset_) {
+    this->reg(PI4IOE5V6408_REGISTER_DEVICE_ID) |= 0b00000001;
+    this->reg(PI4IOE5V6408_REGISTER_OUT_HIGH_IMPEDENCE) = 0b00000000;
+  } else {
+    if (!this->read_gpio_modes_()) {
+      this->mark_failed();
+      ESP_LOGE(TAG, "Failed to read GPIO modes");
+      return;
+    }
+    if (!this->read_gpio_outputs_()) {
+      this->mark_failed();
+      ESP_LOGE(TAG, "Failed to read GPIO outputs");
+      return;
+    }
+  }
+}
+void PI4IOE5V6408Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "PI4IOE5V6408:");
+  LOG_I2C_DEVICE(this)
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
+}
+void PI4IOE5V6408Component::pin_mode(uint8_t pin, gpio::Flags flags) {
+  if (flags & gpio::FLAG_OUTPUT) {
+    // Set mode mask bit
+    this->mode_mask_ |= 1 << pin;
+  } else if (flags & gpio::FLAG_INPUT) {
+    // Clear mode mask bit
+    this->mode_mask_ &= ~(1 << pin);
+    if (flags & gpio::FLAG_PULLUP) {
+      this->pull_up_down_mask_ |= 1 << pin;
+      this->pull_enable_mask_ |= 1 << pin;
+    } else if (flags & gpio::FLAG_PULLDOWN) {
+      this->pull_up_down_mask_ &= ~(1 << pin);
+      this->pull_enable_mask_ |= 1 << pin;
+    }
+  }
+  // Write GPIO to enable input mode
+  this->write_gpio_modes_();
+}
+
+void PI4IOE5V6408Component::loop() { this->reset_pin_cache_(); }
+
+bool PI4IOE5V6408Component::read_gpio_outputs_() {
+  if (this->is_failed())
+    return false;
+
+  uint8_t data;
+  if (!this->read_byte(PI4IOE5V6408_REGISTER_OUT_SET, &data)) {
+    this->status_set_warning("Failed to read output register");
+    return false;
+  }
+  this->output_mask_ = data;
+  this->status_clear_warning();
+  return true;
+}
+
+bool PI4IOE5V6408Component::read_gpio_modes_() {
+  if (this->is_failed())
+    return false;
+
+  uint8_t data;
+  if (!this->read_byte(PI4IOE5V6408_REGISTER_IO_DIR, &data)) {
+    this->status_set_warning("Failed to read GPIO modes");
+    return false;
+  }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  ESP_LOGV(TAG, "Read GPIO modes: 0b" BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(data));
+#endif
+  this->mode_mask_ = data;
+  this->status_clear_warning();
+  return true;
+}
+
+bool PI4IOE5V6408Component::digital_read_hw(uint8_t pin) {
+  if (this->is_failed())
+    return false;
+
+  uint8_t data;
+  if (!this->read_byte(PI4IOE5V6408_REGISTER_IN_STATE, &data)) {
+    this->status_set_warning("Failed to read GPIO state");
+    return false;
+  }
+  this->input_mask_ = data;
+  this->status_clear_warning();
+  return true;
+}
+
+void PI4IOE5V6408Component::digital_write_hw(uint8_t pin, bool value) {
+  if (this->is_failed())
+    return;
+
+  if (value) {
+    this->output_mask_ |= (1 << pin);
+  } else {
+    this->output_mask_ &= ~(1 << pin);
+  }
+  if (!this->write_byte(PI4IOE5V6408_REGISTER_OUT_SET, this->output_mask_)) {
+    this->status_set_warning("Failed to write output register");
+    return;
+  }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  ESP_LOGV(TAG, "Wrote GPIO output: 0b" BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(this->output_mask_));
+#endif
+  this->status_clear_warning();
+}
+
+bool PI4IOE5V6408Component::write_gpio_modes_() {
+  if (this->is_failed())
+    return false;
+
+  if (!this->write_byte(PI4IOE5V6408_REGISTER_IO_DIR, this->mode_mask_)) {
+    this->status_set_warning("Failed to write GPIO modes");
+    return false;
+  }
+  if (!this->write_byte(PI4IOE5V6408_REGISTER_PULL_SELECT, this->pull_up_down_mask_)) {
+    this->status_set_warning("Failed to write GPIO pullup/pulldown");
+    return false;
+  }
+  if (!this->write_byte(PI4IOE5V6408_REGISTER_PULL_ENABLE, this->pull_enable_mask_)) {
+    this->status_set_warning("Failed to write GPIO pull enable");
+    return false;
+  }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  ESP_LOGV(TAG,
+           "Wrote GPIO modes: 0b" BYTE_TO_BINARY_PATTERN "\n"
+           "Wrote GPIO pullup/pulldown: 0b" BYTE_TO_BINARY_PATTERN "\n"
+           "Wrote GPIO pull enable: 0b" BYTE_TO_BINARY_PATTERN,
+           BYTE_TO_BINARY(this->mode_mask_), BYTE_TO_BINARY(this->pull_up_down_mask_),
+           BYTE_TO_BINARY(this->pull_enable_mask_));
+#endif
+  this->status_clear_warning();
+  return true;
+}
+
+bool PI4IOE5V6408Component::digital_read_cache(uint8_t pin) { return (this->input_mask_ & (1 << pin)); }
+
+float PI4IOE5V6408Component::get_setup_priority() const { return setup_priority::IO; }
+
+void PI4IOE5V6408GPIOPin::setup() { this->pin_mode(this->flags_); }
+void PI4IOE5V6408GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
+bool PI4IOE5V6408GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
+void PI4IOE5V6408GPIOPin::digital_write(bool value) {
+  this->parent_->digital_write(this->pin_, value != this->inverted_);
+}
+std::string PI4IOE5V6408GPIOPin::dump_summary() const { return str_sprintf("%u via PI4IOE5V6408", this->pin_); }
+
+}  // namespace pi4ioe5v6408
+}  // namespace esphome

esphome/components/pi4ioe5v6408/pi4ioe5v6408.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "esphome/components/gpio_expander/cached_gpio.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace pi4ioe5v6408 {
+class PI4IOE5V6408Component : public Component,
+                              public i2c::I2CDevice,
+                              public gpio_expander::CachedGpioExpander<uint8_t, 8> {
+ public:
+  PI4IOE5V6408Component() = default;
+
+  void setup() override;
+  void pin_mode(uint8_t pin, gpio::Flags flags);
+
+  float get_setup_priority() const override;
+  void dump_config() override;
+  void loop() override;
+
+  /// Indicate if the component should reset the state during setup
+  void set_reset(bool reset) { this->reset_ = reset; }
+
+ protected:
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
+  /// Mask for the pin mode - 1 means output, 0 means input
+  uint8_t mode_mask_{0x00};
+  /// The mask to write as output state - 1 means HIGH, 0 means LOW
+  uint8_t output_mask_{0x00};
+  /// The state read in digital_read_hw - 1 means HIGH, 0 means LOW
+  uint8_t input_mask_{0x00};
+  /// The mask to write as input buffer state - 1 means enabled, 0 means disabled
+  uint8_t pull_enable_mask_{0x00};
+  /// The mask to write as pullup state - 1 means pullup, 0 means pulldown
+  uint8_t pull_up_down_mask_{0x00};
+
+  bool reset_{true};
+
+  bool read_gpio_modes_();
+  bool write_gpio_modes_();
+  bool read_gpio_outputs_();
+};
+
+class PI4IOE5V6408GPIOPin : public GPIOPin, public Parented<PI4IOE5V6408Component> {
+ public:
+  void setup() override;
+  void pin_mode(gpio::Flags flags) override;
+  bool digital_read() override;
+  void digital_write(bool value) override;
+  std::string dump_summary() const override;
+
+  void set_pin(uint8_t pin) { this->pin_ = pin; }
+  void set_inverted(bool inverted) { this->inverted_ = inverted; }
+  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
+
+  gpio::Flags get_flags() const override { return this->flags_; }
+
+ protected:
+  uint8_t pin_;
+  bool inverted_;
+  gpio::Flags flags_;
+};
+
+}  // namespace pi4ioe5v6408
+}  // namespace esphome

esphome/components/pmsa003i/pmsa003i.h

@@ -32,7 +32,6 @@ class PMSA003IComponent : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_standard_units(bool standard_units) { this->standard_units_ = standard_units; }
 

esphome/components/pmsx003/pmsx003.h

@@ -31,7 +31,6 @@ enum PMSX003State {
 class PMSX003Component : public uart::UARTDevice, public Component {
  public:
   PMSX003Component() = default;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void dump_config() override;
   void loop() override;
 

esphome/components/pn7150/pn7150.cpp

@@ -584,7 +584,7 @@ void PN7150::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_INIT);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_INIT:
       if (this->init_core_() != nfc::STATUS_OK) {
@@ -594,7 +594,7 @@ void PN7150::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_CONFIG);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_CONFIG:
       if (this->send_init_config_() != nfc::STATUS_OK) {
@@ -605,7 +605,7 @@ void PN7150::nci_fsm_transition_() {
         this->config_refresh_pending_ = false;
         this->nci_fsm_set_state_(NCIState::NFCC_SET_DISCOVER_MAP);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_SET_DISCOVER_MAP:
       if (this->set_discover_map_() != nfc::STATUS_OK) {
@@ -615,7 +615,7 @@ void PN7150::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_SET_LISTEN_MODE_ROUTING);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_SET_LISTEN_MODE_ROUTING:
       if (this->set_listen_mode_routing_() != nfc::STATUS_OK) {
@@ -625,7 +625,7 @@ void PN7150::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::RFST_IDLE);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::RFST_IDLE:
       if (this->nci_state_error_ == NCIState::RFST_DISCOVERY) {
@@ -650,14 +650,14 @@ void PN7150::nci_fsm_transition_() {
 
     case NCIState::RFST_W4_HOST_SELECT:
       select_endpoint_();
-      // fall through
+      [[fallthrough]];
 
     // All cases below are waiting for NOTIFICATION messages
     case NCIState::RFST_DISCOVERY:
       if (this->config_refresh_pending_) {
         this->refresh_core_config_();
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::RFST_LISTEN_ACTIVE:
     case NCIState::RFST_LISTEN_SLEEP:

esphome/components/pn7150/pn7150.h

@@ -146,7 +146,6 @@ class PN7150 : public nfc::Nfcc, public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void loop() override;
 
   void set_irq_pin(GPIOPin *irq_pin) { this->irq_pin_ = irq_pin; }

esphome/components/pn7160/pn7160.cpp

@@ -609,7 +609,7 @@ void PN7160::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_INIT);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_INIT:
       if (this->init_core_() != nfc::STATUS_OK) {
@@ -619,7 +619,7 @@ void PN7160::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_CONFIG);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_CONFIG:
       if (this->send_init_config_() != nfc::STATUS_OK) {
@@ -630,7 +630,7 @@ void PN7160::nci_fsm_transition_() {
         this->config_refresh_pending_ = false;
         this->nci_fsm_set_state_(NCIState::NFCC_SET_DISCOVER_MAP);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_SET_DISCOVER_MAP:
       if (this->set_discover_map_() != nfc::STATUS_OK) {
@@ -640,7 +640,7 @@ void PN7160::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::NFCC_SET_LISTEN_MODE_ROUTING);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::NFCC_SET_LISTEN_MODE_ROUTING:
       if (this->set_listen_mode_routing_() != nfc::STATUS_OK) {
@@ -650,7 +650,7 @@ void PN7160::nci_fsm_transition_() {
       } else {
         this->nci_fsm_set_state_(NCIState::RFST_IDLE);
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::RFST_IDLE:
       if (this->nci_state_error_ == NCIState::RFST_DISCOVERY) {
@@ -675,14 +675,14 @@ void PN7160::nci_fsm_transition_() {
 
     case NCIState::RFST_W4_HOST_SELECT:
       select_endpoint_();
-      // fall through
+      [[fallthrough]];
 
     // All cases below are waiting for NOTIFICATION messages
     case NCIState::RFST_DISCOVERY:
       if (this->config_refresh_pending_) {
         this->refresh_core_config_();
       }
-      // fall through
+      [[fallthrough]];
 
     case NCIState::RFST_LISTEN_ACTIVE:
     case NCIState::RFST_LISTEN_SLEEP:

esphome/components/pn7160/pn7160.h

@@ -161,7 +161,6 @@ class PN7160 : public nfc::Nfcc, public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void loop() override;
 
   void set_dwl_req_pin(GPIOPin *dwl_req_pin) { this->dwl_req_pin_ = dwl_req_pin; }

esphome/components/preferences/syncer.h

@@ -12,6 +12,8 @@ class IntervalSyncer : public Component {
   void setup() override {
     if (this->write_interval_ != 0) {
       set_interval(this->write_interval_, []() { global_preferences->sync(); });
+      // When using interval-based syncing, we don't need the loop
+      this->disable_loop();
     }
   }
   void loop() override {

esphome/components/prometheus/prometheus_handler.h

@@ -40,7 +40,7 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
    */
   void add_label_name(EntityBase *obj, const std::string &value) { relabel_map_name_.insert({obj, value}); }
 
-  bool canHandle(AsyncWebServerRequest *request) override {
+  bool canHandle(AsyncWebServerRequest *request) const override {
     if (request->method() == HTTP_GET) {
       if (request->url() == "/metrics")
         return true;

esphome/components/psram/psram.cpp

@@ -2,9 +2,7 @@
 #ifdef USE_ESP32
 #include "psram.h"
 #include <esp_idf_version.h>
-#if defined(USE_ESP_IDF) && ESP_IDF_VERSION_MAJOR >= 5
 #include <esp_psram.h>
-#endif  // USE_ESP_IDF
 
 #include "esphome/core/log.h"
 
@@ -16,7 +14,6 @@ static const char *const TAG = "psram";
 
 void PsramComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "PSRAM:");
-#if defined(USE_ESP_IDF) && ESP_IDF_VERSION_MAJOR >= 5
   bool available = esp_psram_is_initialized();
 
   ESP_LOGCONFIG(TAG, "  Available: %s", YESNO(available));
@@ -26,23 +23,6 @@ void PsramComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "  ECC enabled: YES");
 #endif
   }
-#else
-  // Technically this can be false if the PSRAM is full, but heap_caps_get_total_size() isn't always available, and it's
-  // very unlikely for the PSRAM to be full.
-  bool available = heap_caps_get_free_size(MALLOC_CAP_SPIRAM) > 0;
-  ESP_LOGCONFIG(TAG, "  Available: %s", YESNO(available));
-
-  if (available) {
-    const size_t psram_total_size_bytes = heap_caps_get_total_size(MALLOC_CAP_SPIRAM);
-    const float psram_total_size_kb = psram_total_size_bytes / 1024.0f;
-
-    if (abs(std::round(psram_total_size_kb) - psram_total_size_kb) < 0.05f) {
-      ESP_LOGCONFIG(TAG, "  Size: %.0f KB", psram_total_size_kb);
-    } else {
-      ESP_LOGCONFIG(TAG, "  Size: %zu bytes", psram_total_size_bytes);
-    }
-  }
-#endif  // USE_ESP_IDF
 }
 
 }  // namespace psram

esphome/components/pulse_counter/pulse_counter_sensor.h

@@ -76,7 +76,6 @@ class PulseCounterSensor : public sensor::Sensor, public PollingComponent {
   /// Unit of measurement is "pulses/min".
   void setup() override;
   void update() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void dump_config() override;
 
  protected: