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

esphome/components/opt3001/opt3001.cpp

@@ -0,0 +1,122 @@
+#include "opt3001.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace opt3001 {
+
+static const char *const TAG = "opt3001.sensor";
+
+static const uint8_t OPT3001_REG_RESULT = 0x00;
+static const uint8_t OPT3001_REG_CONFIGURATION = 0x01;
+// See datasheet for full description of each bit.
+static const uint16_t OPT3001_CONFIGURATION_RANGE_FULL = 0b1100000000000000;
+static const uint16_t OPT3001_CONFIGURATION_CONVERSION_TIME_800 = 0b100000000000;
+static const uint16_t OPT3001_CONFIGURATION_CONVERSION_MODE_MASK = 0b11000000000;
+static const uint16_t OPT3001_CONFIGURATION_CONVERSION_MODE_SINGLE_SHOT = 0b01000000000;
+static const uint16_t OPT3001_CONFIGURATION_CONVERSION_MODE_SHUTDOWN = 0b00000000000;
+// tl;dr: Configure an automatic-ranged, 800ms single shot reading,
+// with INT processing disabled
+static const uint16_t OPT3001_CONFIGURATION_FULL_RANGE_ONE_SHOT = OPT3001_CONFIGURATION_RANGE_FULL |
+                                                                  OPT3001_CONFIGURATION_CONVERSION_TIME_800 |
+                                                                  OPT3001_CONFIGURATION_CONVERSION_MODE_SINGLE_SHOT;
+static const uint16_t OPT3001_CONVERSION_TIME_800 = 825;  // give it 25 extra ms; it seems to not be ready quite often
+
+/*
+opt3001 properties:
+
+- e (exponent) = high 4 bits of result register
+- m (mantissa) = low 12 bits of result register
+- formula: (0.01 * 2^e) * m lx
+
+*/
+
+void OPT3001Sensor::read_result_(const std::function<void(float)> &f) {
+  // ensure the single shot flag is clear, indicating it's done
+  uint16_t raw_value;
+  if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Reading configuration register failed");
+    f(NAN);
+    return;
+  }
+  raw_value = i2c::i2ctohs(raw_value);
+
+  if ((raw_value & OPT3001_CONFIGURATION_CONVERSION_MODE_MASK) != OPT3001_CONFIGURATION_CONVERSION_MODE_SHUTDOWN) {
+    // not ready; wait 10ms and try again
+    ESP_LOGW(TAG, "Data not ready; waiting 10ms");
+    this->set_timeout("opt3001_wait", 10, [this, f]() { read_result_(f); });
+    return;
+  }
+
+  if (this->read_register(OPT3001_REG_RESULT, reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Reading result register failed");
+    f(NAN);
+    return;
+  }
+  raw_value = i2c::i2ctohs(raw_value);
+
+  uint8_t exponent = raw_value >> 12;
+  uint16_t mantissa = raw_value & 0b111111111111;
+
+  double lx = 0.01 * pow(2.0, double(exponent)) * double(mantissa);
+  f(float(lx));
+}
+
+void OPT3001Sensor::read_lx_(const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint16_t start_measurement = i2c::htoi2cs(OPT3001_CONFIGURATION_FULL_RANGE_ONE_SHOT);
+  if (this->write_register(OPT3001_REG_CONFIGURATION, reinterpret_cast<uint8_t *>(&start_measurement), 2) !=
+      i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Triggering one shot measurement failed");
+    f(NAN);
+    return;
+  }
+
+  this->set_timeout("read", OPT3001_CONVERSION_TIME_800, [this, f]() {
+    if (this->write(&OPT3001_REG_CONFIGURATION, 1, true) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Starting configuration register read failed");
+      f(NAN);
+      return;
+    }
+
+    this->read_result_(f);
+  });
+}
+
+void OPT3001Sensor::dump_config() {
+  LOG_SENSOR("", "OPT3001", this);
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
+
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void OPT3001Sensor::update() {
+  // Set a flag and skip just in case the sensor isn't responding,
+  // and we just keep waiting for it in read_result_.
+  // This way we don't end up with potentially boundless "threads"
+  // using up memory and eventually crashing the device
+  if (this->updating_) {
+    return;
+  }
+  this->updating_ = true;
+
+  this->read_lx_([this](float val) {
+    this->updating_ = false;
+
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
+      return;
+    }
+    ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), val);
+    this->status_clear_warning();
+    this->publish_state(val);
+  });
+}
+
+float OPT3001Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
+}  // namespace opt3001
+}  // namespace esphome

esphome/components/opt3001/opt3001.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace opt3001 {
+
+/// This class implements support for the i2c-based OPT3001 ambient light sensor.
+class OPT3001Sensor : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
+ public:
+  void dump_config() override;
+  void update() override;
+  float get_setup_priority() const override;
+
+ protected:
+  // checks if one-shot is complete before reading the result and returning it
+  void read_result_(const std::function<void(float)> &f);
+  // begins a one-shot measurement
+  void read_lx_(const std::function<void(float)> &f);
+
+  bool updating_{false};
+};
+
+}  // namespace opt3001
+}  // namespace esphome

esphome/components/opt3001/sensor.py

@@ -0,0 +1,35 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    DEVICE_CLASS_ILLUMINANCE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_LUX,
+)
+
+DEPENDENCIES = ["i2c"]
+CODEOWNERS = ["@ccutrer"]
+
+opt3001_ns = cg.esphome_ns.namespace("opt3001")
+
+OPT3001Sensor = opt3001_ns.class_(
+    "OPT3001Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice
+)
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        OPT3001Sensor,
+        unit_of_measurement=UNIT_LUX,
+        accuracy_decimals=1,
+        device_class=DEVICE_CLASS_ILLUMINANCE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x44))
+)
+
+
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/ota/__init__.py

@@ -1,5 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ESPHOME,
@@ -7,6 +8,7 @@ from esphome.const import (
     CONF_OTA,
     CONF_PLATFORM,
     CONF_TRIGGER_ID,
+    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 
@@ -120,3 +122,18 @@ async def ota_to_code(var, config):
         use_state_callback = True
     if use_state_callback:
         cg.add_define("USE_OTA_STATE_CALLBACK")
+
+
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "ota_backend_arduino_esp32.cpp": {PlatformFramework.ESP32_ARDUINO},
+        "ota_backend_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
+        "ota_backend_arduino_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "ota_backend_arduino_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
+        "ota_backend_arduino_libretiny.cpp": {
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
+    }
+)

esphome/components/ota/ota_backend.h

@@ -67,7 +67,28 @@ class OTAComponent : public Component {
   }
 
  protected:
-  CallbackManager<void(ota::OTAState, float, uint8_t)> state_callback_{};
+  /** Extended callback manager with deferred call support.
+   *
+   * This adds a call_deferred() method for thread-safe execution from other tasks.
+   */
+  class StateCallbackManager : public CallbackManager<void(OTAState, float, uint8_t)> {
+   public:
+    StateCallbackManager(OTAComponent *component) : component_(component) {}
+
+    /** Call callbacks with deferral to main loop (for thread safety).
+     *
+     * This should be used by OTA implementations that run in separate tasks
+     * (like web_server OTA) to ensure callbacks execute in the main loop.
+     */
+    void call_deferred(ota::OTAState state, float progress, uint8_t error) {
+      component_->defer([this, state, progress, error]() { this->call(state, progress, error); });
+    }
+
+   private:
+    OTAComponent *component_;
+  };
+
+  StateCallbackManager state_callback_{this};
 #endif
 };
 
@@ -89,6 +110,11 @@ class OTAGlobalCallback {
 
 OTAGlobalCallback *get_global_ota_callback();
 void register_ota_platform(OTAComponent *ota_caller);
+
+// OTA implementations should use:
+// - state_callback_.call() when already in main loop (e.g., esphome OTA)
+// - state_callback_.call_deferred() when in separate task (e.g., web_server OTA)
+// This ensures proper callback execution in all contexts.
 #endif
 std::unique_ptr<ota::OTABackend> make_ota_backend();
 

esphome/components/ota/ota_backend_arduino_esp32.cpp

@@ -15,6 +15,11 @@ static const char *const TAG = "ota.arduino_esp32";
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP32OTABackend>(); }
 
 OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) which is used by web server OTA
+  // where the exact firmware size is unknown due to multipart encoding
+  if (image_size == 0) {
+    image_size = UPDATE_SIZE_UNKNOWN;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     return OTA_RESPONSE_OK;
@@ -29,7 +34,10 @@ OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoESP32OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoESP32OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoESP32OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -44,7 +52,9 @@ OTAResponseTypes ArduinoESP32OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoESP32OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 

esphome/components/ota/ota_backend_arduino_esp32.h

@@ -16,6 +16,9 @@ class ArduinoESP32OTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
 }  // namespace ota

esphome/components/ota/ota_backend_arduino_esp8266.cpp

@@ -17,6 +17,11 @@ static const char *const TAG = "ota.arduino_esp8266";
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP8266OTABackend>(); }
 
 OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
+  if (image_size == 0) {
+    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+    image_size = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     esp8266::preferences_prevent_write(true);
@@ -38,7 +43,10 @@ OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoESP8266OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoESP8266OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -53,13 +61,19 @@ OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoESP8266OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  bool success = Update.end(!this->md5_set_);
+
+  // On ESP8266, Update.end() might return false even with error code 0
+  // Check the actual error code to determine success
+  uint8_t error = Update.getError();
+
+  if (success || error == UPDATE_ERROR_OK) {
     return OTA_RESPONSE_OK;
   }
 
-  uint8_t error = Update.getError();
   ESP_LOGE(TAG, "End error: %d", error);
-
   return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 

esphome/components/ota/ota_backend_arduino_esp8266.h

@@ -21,6 +21,9 @@ class ArduinoESP8266OTABackend : public OTABackend {
 #else
   bool supports_compression() override { return false; }
 #endif
+
+ private:
+  bool md5_set_{false};
 };
 
 }  // namespace ota

esphome/components/ota/ota_backend_arduino_libretiny.cpp

@@ -15,6 +15,11 @@ static const char *const TAG = "ota.arduino_libretiny";
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoLibreTinyOTABackend>(); }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) which is used by web server OTA
+  // where the exact firmware size is unknown due to multipart encoding
+  if (image_size == 0) {
+    image_size = UPDATE_SIZE_UNKNOWN;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     return OTA_RESPONSE_OK;
@@ -29,7 +34,10 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoLibreTinyOTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoLibreTinyOTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -44,7 +52,9 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 

esphome/components/ota/ota_backend_arduino_libretiny.h

@@ -15,6 +15,9 @@ class ArduinoLibreTinyOTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
 }  // namespace ota

esphome/components/ota/ota_backend_arduino_rp2040.cpp

@@ -17,6 +17,8 @@ static const char *const TAG = "ota.arduino_rp2040";
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoRP2040OTABackend>(); }
 
 OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
+  // OTA size of 0 is not currently handled, but
+  // web_server is not supported for RP2040, so this is not an issue.
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     rp2040::preferences_prevent_write(true);
@@ -38,7 +40,10 @@ OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoRP2040OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoRP2040OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoRP2040OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -53,7 +58,9 @@ OTAResponseTypes ArduinoRP2040OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoRP2040OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 

esphome/components/ota/ota_backend_arduino_rp2040.h

@@ -17,6 +17,9 @@ class ArduinoRP2040OTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
 }  // namespace ota

esphome/components/ota/ota_backend_esp_idf.cpp

@@ -6,10 +6,7 @@
 
 #include <esp_ota_ops.h>
 #include <esp_task_wdt.h>
-
-#if ESP_IDF_VERSION_MAJOR >= 5
 #include <spi_flash_mmap.h>
-#endif
 
 namespace esphome {
 namespace ota {
@@ -24,7 +21,6 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
 
 #if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
   // The following function takes longer than the 5 seconds timeout of WDT
-#if ESP_IDF_VERSION_MAJOR >= 5
   esp_task_wdt_config_t wdtc;
   wdtc.idle_core_mask = 0;
 #if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
@@ -36,21 +32,14 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
   wdtc.timeout_ms = 15000;
   wdtc.trigger_panic = false;
   esp_task_wdt_reconfigure(&wdtc);
-#else
-  esp_task_wdt_init(15, false);
-#endif
 #endif
 
   esp_err_t err = esp_ota_begin(this->partition_, image_size, &this->update_handle_);
 
 #if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
   // Set the WDT back to the configured timeout
-#if ESP_IDF_VERSION_MAJOR >= 5
   wdtc.timeout_ms = CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000;
   esp_task_wdt_reconfigure(&wdtc);
-#else
-  esp_task_wdt_init(CONFIG_ESP_TASK_WDT_TIMEOUT_S, false);
-#endif
 #endif
 
   if (err != ESP_OK) {
@@ -67,7 +56,10 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_OK;
 }
 
-void IDFOTABackend::set_update_md5(const char *expected_md5) { memcpy(this->expected_bin_md5_, expected_md5, 32); }
+void IDFOTABackend::set_update_md5(const char *expected_md5) {
+  memcpy(this->expected_bin_md5_, expected_md5, 32);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
   esp_err_t err = esp_ota_write(this->update_handle_, data, len);
@@ -84,10 +76,12 @@ OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes IDFOTABackend::end() {
-  this->md5_.calculate();
-  if (!this->md5_.equals_hex(this->expected_bin_md5_)) {
-    this->abort();
-    return OTA_RESPONSE_ERROR_MD5_MISMATCH;
+  if (this->md5_set_) {
+    this->md5_.calculate();
+    if (!this->md5_.equals_hex(this->expected_bin_md5_)) {
+      this->abort();
+      return OTA_RESPONSE_ERROR_MD5_MISMATCH;
+    }
   }
   esp_err_t err = esp_ota_end(this->update_handle_);
   this->update_handle_ = 0;

esphome/components/ota/ota_backend_esp_idf.h

@@ -24,6 +24,7 @@ class IDFOTABackend : public OTABackend {
   const esp_partition_t *partition_;
   md5::MD5Digest md5_{};
   char expected_bin_md5_[32];
+  bool md5_set_{false};
 };
 
 }  // namespace ota

esphome/components/packages/__init__.py

@@ -63,6 +63,7 @@ BASE_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Required(CONF_URL): cv.url,
+            cv.Optional(CONF_PATH): cv.string,
             cv.Optional(CONF_USERNAME): cv.string,
             cv.Optional(CONF_PASSWORD): cv.string,
             cv.Exclusive(CONF_FILE, CONF_FILES): validate_yaml_filename,
@@ -74,7 +75,7 @@ BASE_SCHEMA = cv.All(
                             {
                                 cv.Required(CONF_PATH): validate_yaml_filename,
                                 cv.Optional(CONF_VARS, default={}): cv.Schema(
-                                    {cv.string: cv.string}
+                                    {cv.string: object}
                                 ),
                             }
                         ),
@@ -116,6 +117,9 @@ def _process_base_package(config: dict) -> dict:
     )
     files = []
 
+    if base_path := config.get(CONF_PATH):
+        repo_dir = repo_dir / base_path
+
     for file in config[CONF_FILES]:
         if isinstance(file, str):
             files.append({CONF_PATH: file, CONF_VARS: {}})
@@ -148,7 +152,6 @@ def _process_base_package(config: dict) -> dict:
                         raise cv.Invalid(
                             f"Current ESPHome Version is too old to use this package: {ESPHOME_VERSION} < {min_version}"
                         )
-                vars = {k: str(v) for k, v in vars.items()}
                 new_yaml = yaml_util.substitute_vars(new_yaml, vars)
                 packages[f"{filename}{idx}"] = new_yaml
             except EsphomeError as e:

esphome/components/packet_transport/binary_sensor.py

@@ -1,19 +1,76 @@
 import esphome.codegen as cg
 from esphome.components import binary_sensor
-from esphome.const import CONF_ID
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_DATA,
+    CONF_ID,
+    CONF_NAME,
+    CONF_STATUS,
+    CONF_TYPE,
+    DEVICE_CLASS_CONNECTIVITY,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+)
+import esphome.final_validate as fv
 
 from . import (
+    CONF_ENCRYPTION,
+    CONF_PING_PONG_ENABLE,
     CONF_PROVIDER,
+    CONF_PROVIDERS,
     CONF_REMOTE_ID,
     CONF_TRANSPORT_ID,
+    PacketTransport,
     packet_transport_sensor_schema,
+    provider_name_validate,
+)
+
+STATUS_SENSOR_SCHEMA = binary_sensor.binary_sensor_schema(
+    device_class=DEVICE_CLASS_CONNECTIVITY,
+    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+).extend(
+    {
+        cv.GenerateID(CONF_TRANSPORT_ID): cv.use_id(PacketTransport),
+        cv.Required(CONF_PROVIDER): provider_name_validate,
+    }
+)
+
+CONFIG_SCHEMA = cv.typed_schema(
+    {
+        CONF_DATA: packet_transport_sensor_schema(binary_sensor.binary_sensor_schema()),
+        CONF_STATUS: STATUS_SENSOR_SCHEMA,
+    },
+    key=CONF_TYPE,
+    default_type=CONF_DATA,
 )
 
-CONFIG_SCHEMA = packet_transport_sensor_schema(binary_sensor.binary_sensor_schema())
+
+def _final_validate(config):
+    if config[CONF_TYPE] != CONF_STATUS:
+        # Only run this validation if a status sensor is being configured
+        return config
+    full_config = fv.full_config.get()
+    transport_path = full_config.get_path_for_id(config[CONF_TRANSPORT_ID])[:-1]
+    transport_config = full_config.get_config_for_path(transport_path)
+    if transport_config[CONF_PING_PONG_ENABLE] and any(
+        CONF_ENCRYPTION in p
+        for p in transport_config[CONF_PROVIDERS]
+        if p[CONF_NAME] == config[CONF_PROVIDER]
+    ):
+        return config
+    raise cv.Invalid(
+        "Status sensor requires ping-pong to be enabled and the nominated provider to use encryption."
+    )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
     var = await binary_sensor.new_binary_sensor(config)
     comp = await cg.get_variable(config[CONF_TRANSPORT_ID])
-    remote_id = str(config.get(CONF_REMOTE_ID) or config.get(CONF_ID))
-    cg.add(comp.add_remote_binary_sensor(config[CONF_PROVIDER], remote_id, var))
+    if config[CONF_TYPE] == CONF_STATUS:
+        cg.add(comp.set_provider_status_sensor(config[CONF_PROVIDER], var))
+        cg.add_define("USE_STATUS_SENSOR")
+    else:  # CONF_DATA is default
+        remote_id = str(config.get(CONF_REMOTE_ID) or config.get(CONF_ID))
+        cg.add(comp.add_remote_binary_sensor(config[CONF_PROVIDER], remote_id, var))