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

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:

esphome/components/pulse_meter/pulse_meter_sensor.cpp

@@ -31,6 +31,10 @@ void PulseMeterSensor::setup() {
     this->pulse_state_.latched_ = this->last_pin_val_;
     this->pin_->attach_interrupt(PulseMeterSensor::pulse_intr, this, gpio::INTERRUPT_ANY_EDGE);
   }
+
+  if (this->total_sensor_ != nullptr) {
+    this->total_sensor_->publish_state(this->total_pulses_);
+  }
 }
 
 void PulseMeterSensor::loop() {
@@ -63,7 +67,7 @@ void PulseMeterSensor::loop() {
   // If an edge was peeked, repay the debt
   if (this->peeked_edge_ && this->get_->count_ > 0) {
     this->peeked_edge_ = false;
-    this->get_->count_--;
+    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
@@ -71,7 +75,7 @@ void PulseMeterSensor::loop() {
       now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
     this->peeked_edge_ = true;
     this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
-    this->get_->count_++;
+    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Check if we detected a pulse this loop
@@ -146,7 +150,7 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
     state.last_sent_edge_us_ = now;
     set.last_detected_edge_us_ = now;
     set.last_rising_edge_us_ = now;
-    set.count_++;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // This ISR is bound to rising edges, so the pin is high
@@ -169,7 +173,7 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
   } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
     state.latched_ = true;
     set.last_detected_edge_us_ = state.last_intr_;
-    set.count_++;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Due to order of operations this includes

esphome/components/pulse_width/pulse_width.h

@@ -32,7 +32,6 @@ class PulseWidthSensor : public sensor::Sensor, public PollingComponent {
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
   void setup() override { this->store_.setup(this->pin_); }
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void update() override;
 
  protected:

esphome/components/pvvx_mithermometer/display/pvvx_display.cpp

@@ -146,11 +146,7 @@ void PVVXDisplay::sync_time_() {
   }
   time.recalc_timestamp_utc(true);  // calculate timestamp of local time
   uint8_t blk[5] = {};
-#if ESP_IDF_VERSION_MAJOR >= 5
   ESP_LOGD(TAG, "[%s] Sync time with timestamp %" PRIu64 ".", this->parent_->address_str().c_str(), time.timestamp);
-#else
-  ESP_LOGD(TAG, "[%s] Sync time with timestamp %lu.", this->parent_->address_str().c_str(), time.timestamp);
-#endif
   blk[0] = 0x23;
   blk[1] = time.timestamp & 0xff;
   blk[2] = (time.timestamp >> 8) & 0xff;

esphome/components/pvvx_mithermometer/display/pvvx_display.h

@@ -39,8 +39,6 @@ class PVVXDisplay : public ble_client::BLEClientNode, public PollingComponent {
 
   void dump_config() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
   void update() override;
 
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,

esphome/components/pvvx_mithermometer/pvvx_mithermometer.h

@@ -25,7 +25,6 @@ class PVVXMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevic
 
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
   void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
   void set_battery_level(sensor::Sensor *battery_level) { battery_level_ = battery_level; }

esphome/components/qr_code/__init__.py

@@ -21,21 +21,24 @@ ECC = {
     "HIGH": qrcodegen_Ecc.qrcodegen_Ecc_HIGH,
 }
 
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.declare_id(QRCode),
-        cv.Required(CONF_VALUE): cv.string,
-        cv.Optional(CONF_ECC, default="LOW"): cv.enum(ECC, upper=True),
-    }
+CONFIG_SCHEMA = cv.ensure_list(
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.declare_id(QRCode),
+            cv.Required(CONF_VALUE): cv.string,
+            cv.Optional(CONF_ECC, default="LOW"): cv.enum(ECC, upper=True),
+        }
+    )
 )
 
 
 async def to_code(config):
     cg.add_library("wjtje/qr-code-generator-library", "^1.7.0")
 
-    var = cg.new_Pvariable(config[CONF_ID])
-    cg.add(var.set_value(config[CONF_VALUE]))
-    cg.add(var.set_ecc(ECC[config[CONF_ECC]]))
-    await cg.register_component(var, config)
+    for entry in config:
+        var = cg.new_Pvariable(entry[CONF_ID])
+        cg.add(var.set_value(entry[CONF_VALUE]))
+        cg.add(var.set_ecc(ECC[entry[CONF_ECC]]))
+        await cg.register_component(var, entry)
 
     cg.add_define("USE_QR_CODE")