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

esphome/components/esp32_camera/esp32_camera.h

@@ -2,22 +2,23 @@
 
 #ifdef USE_ESP32
 
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "esphome/core/entity_base.h"
-#include "esphome/core/helpers.h"
 #include <esp_camera.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/queue.h>
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/components/camera/camera.h"
+#include "esphome/core/helpers.h"
+
+#ifdef USE_I2C
+#include "esphome/components/i2c/i2c_bus.h"
+#endif  // USE_I2C
 
 namespace esphome {
 namespace esp32_camera {
 
 class ESP32Camera;
 
-/* ---------------- enum classes ---------------- */
-enum CameraRequester { IDLE, API_REQUESTER, WEB_REQUESTER };
-
 enum ESP32CameraFrameSize {
   ESP32_CAMERA_SIZE_160X120,    // QQVGA
   ESP32_CAMERA_SIZE_176X144,    // QCIF
@@ -73,13 +74,13 @@ enum ESP32SpecialEffect {
 };
 
 /* ---------------- CameraImage class ---------------- */
-class CameraImage {
+class ESP32CameraImage : public camera::CameraImage {
  public:
-  CameraImage(camera_fb_t *buffer, uint8_t requester);
+  ESP32CameraImage(camera_fb_t *buffer, uint8_t requester);
   camera_fb_t *get_raw_buffer();
-  uint8_t *get_data_buffer();
-  size_t get_data_length();
-  bool was_requested_by(CameraRequester requester) const;
+  uint8_t *get_data_buffer() override;
+  size_t get_data_length() override;
+  bool was_requested_by(camera::CameraRequester requester) const override;
 
  protected:
   camera_fb_t *buffer_;
@@ -92,21 +93,21 @@ struct CameraImageData {
 };
 
 /* ---------------- CameraImageReader class ---------------- */
-class CameraImageReader {
+class ESP32CameraImageReader : public camera::CameraImageReader {
  public:
-  void set_image(std::shared_ptr<CameraImage> image);
-  size_t available() const;
-  uint8_t *peek_data_buffer();
-  void consume_data(size_t consumed);
-  void return_image();
+  void set_image(std::shared_ptr<camera::CameraImage> image) override;
+  size_t available() const override;
+  uint8_t *peek_data_buffer() override;
+  void consume_data(size_t consumed) override;
+  void return_image() override;
 
  protected:
-  std::shared_ptr<CameraImage> image_;
+  std::shared_ptr<ESP32CameraImage> image_;
   size_t offset_{0};
 };
 
 /* ---------------- ESP32Camera class ---------------- */
-class ESP32Camera : public EntityBase, public Component {
+class ESP32Camera : public camera::Camera {
  public:
   ESP32Camera();
 
@@ -118,6 +119,9 @@ class ESP32Camera : public EntityBase, public Component {
   void set_pixel_clock_pin(uint8_t pin);
   void set_external_clock(uint8_t pin, uint32_t frequency);
   void set_i2c_pins(uint8_t sda, uint8_t scl);
+#ifdef USE_I2C
+  void set_i2c_id(i2c::InternalI2CBus *i2c_bus);
+#endif  // USE_I2C
   void set_reset_pin(uint8_t pin);
   void set_power_down_pin(uint8_t pin);
   /* -- image */
@@ -155,14 +159,15 @@ class ESP32Camera : public EntityBase, public Component {
   void dump_config() override;
   float get_setup_priority() const override;
   /* public API (specific) */
-  void start_stream(CameraRequester requester);
-  void stop_stream(CameraRequester requester);
-  void request_image(CameraRequester requester);
+  void start_stream(camera::CameraRequester requester) override;
+  void stop_stream(camera::CameraRequester requester) override;
+  void request_image(camera::CameraRequester requester) override;
   void update_camera_parameters();
 
-  void add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback);
+  void add_image_callback(std::function<void(std::shared_ptr<camera::CameraImage>)> &&callback) override;
   void add_stream_start_callback(std::function<void()> &&callback);
   void add_stream_stop_callback(std::function<void()> &&callback);
+  camera::CameraImageReader *create_image_reader() override;
 
  protected:
   /* internal methods */
@@ -199,26 +204,26 @@ class ESP32Camera : public EntityBase, public Component {
   uint32_t idle_update_interval_{15000};
 
   esp_err_t init_error_{ESP_OK};
-  std::shared_ptr<CameraImage> current_image_;
+  std::shared_ptr<ESP32CameraImage> current_image_;
   uint8_t single_requesters_{0};
   uint8_t stream_requesters_{0};
   QueueHandle_t framebuffer_get_queue_;
   QueueHandle_t framebuffer_return_queue_;
-  CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_{};
+  CallbackManager<void(std::shared_ptr<camera::CameraImage>)> new_image_callback_{};
   CallbackManager<void()> stream_start_callback_{};
   CallbackManager<void()> stream_stop_callback_{};
 
   uint32_t last_idle_request_{0};
   uint32_t last_update_{0};
+#ifdef USE_I2C
+  i2c::InternalI2CBus *i2c_bus_{nullptr};
+#endif  // USE_I2C
 };
 
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-extern ESP32Camera *global_esp32_camera;
-
 class ESP32CameraImageTrigger : public Trigger<CameraImageData> {
  public:
   explicit ESP32CameraImageTrigger(ESP32Camera *parent) {
-    parent->add_image_callback([this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
+    parent->add_image_callback([this](const std::shared_ptr<camera::CameraImage> &image) {
       CameraImageData camera_image_data{};
       camera_image_data.length = image->get_data_length();
       camera_image_data.data = image->get_data_buffer();

esphome/components/esp32_camera_web_server/__init__.py

@@ -3,7 +3,8 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MODE, CONF_PORT
 
 CODEOWNERS = ["@ayufan"]
-DEPENDENCIES = ["esp32_camera"]
+AUTO_LOAD = ["camera"]
+DEPENDENCIES = ["network"]
 MULTI_CONF = True
 
 esp32_camera_web_server_ns = cg.esphome_ns.namespace("esp32_camera_web_server")

esphome/components/esp32_camera_web_server/camera_web_server.cpp

@@ -40,7 +40,7 @@ CameraWebServer::CameraWebServer() {}
 CameraWebServer::~CameraWebServer() {}
 
 void CameraWebServer::setup() {
-  if (!esp32_camera::global_esp32_camera || esp32_camera::global_esp32_camera->is_failed()) {
+  if (!camera::Camera::instance() || camera::Camera::instance()->is_failed()) {
     this->mark_failed();
     return;
   }
@@ -67,8 +67,8 @@ void CameraWebServer::setup() {
 
   httpd_register_uri_handler(this->httpd_, &uri);
 
-  esp32_camera::global_esp32_camera->add_image_callback([this](std::shared_ptr<esp32_camera::CameraImage> image) {
-    if (this->running_ && image->was_requested_by(esp32_camera::WEB_REQUESTER)) {
+  camera::Camera::instance()->add_image_callback([this](std::shared_ptr<camera::CameraImage> image) {
+    if (this->running_ && image->was_requested_by(camera::WEB_REQUESTER)) {
       this->image_ = std::move(image);
       xSemaphoreGive(this->semaphore_);
     }
@@ -108,8 +108,8 @@ void CameraWebServer::loop() {
   }
 }
 
-std::shared_ptr<esphome::esp32_camera::CameraImage> CameraWebServer::wait_for_image_() {
-  std::shared_ptr<esphome::esp32_camera::CameraImage> image;
+std::shared_ptr<esphome::camera::CameraImage> CameraWebServer::wait_for_image_() {
+  std::shared_ptr<esphome::camera::CameraImage> image;
   image.swap(this->image_);
 
   if (!image) {
@@ -172,7 +172,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
   uint32_t last_frame = millis();
   uint32_t frames = 0;
 
-  esp32_camera::global_esp32_camera->start_stream(esphome::esp32_camera::WEB_REQUESTER);
+  camera::Camera::instance()->start_stream(esphome::camera::WEB_REQUESTER);
 
   while (res == ESP_OK && this->running_) {
     auto image = this->wait_for_image_();
@@ -205,7 +205,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
     res = httpd_send_all(req, STREAM_ERROR, strlen(STREAM_ERROR));
   }
 
-  esp32_camera::global_esp32_camera->stop_stream(esphome::esp32_camera::WEB_REQUESTER);
+  camera::Camera::instance()->stop_stream(esphome::camera::WEB_REQUESTER);
 
   ESP_LOGI(TAG, "STREAM: closed. Frames: %" PRIu32, frames);
 
@@ -215,7 +215,7 @@ esp_err_t CameraWebServer::streaming_handler_(struct httpd_req *req) {
 esp_err_t CameraWebServer::snapshot_handler_(struct httpd_req *req) {
   esp_err_t res = ESP_OK;
 
-  esp32_camera::global_esp32_camera->request_image(esphome::esp32_camera::WEB_REQUESTER);
+  camera::Camera::instance()->request_image(esphome::camera::WEB_REQUESTER);
 
   auto image = this->wait_for_image_();
 

esphome/components/esp32_camera_web_server/camera_web_server.h

@@ -6,7 +6,7 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 
-#include "esphome/components/esp32_camera/esp32_camera.h"
+#include "esphome/components/camera/camera.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
@@ -32,7 +32,7 @@ class CameraWebServer : public Component {
   void loop() override;
 
  protected:
-  std::shared_ptr<esphome::esp32_camera::CameraImage> wait_for_image_();
+  std::shared_ptr<camera::CameraImage> wait_for_image_();
   esp_err_t handler_(struct httpd_req *req);
   esp_err_t streaming_handler_(struct httpd_req *req);
   esp_err_t snapshot_handler_(struct httpd_req *req);
@@ -40,7 +40,7 @@ class CameraWebServer : public Component {
   uint16_t port_{0};
   void *httpd_{nullptr};
   SemaphoreHandle_t semaphore_;
-  std::shared_ptr<esphome::esp32_camera::CameraImage> image_;
+  std::shared_ptr<camera::CameraImage> image_;
   bool running_{false};
   Mode mode_{STREAM};
 };

esphome/components/esp32_hall/sensor.py

@@ -1,24 +1,5 @@
-import esphome.codegen as cg
-from esphome.components import sensor
 import esphome.config_validation as cv
-from esphome.const import ICON_MAGNET, STATE_CLASS_MEASUREMENT, UNIT_MICROTESLA
 
-DEPENDENCIES = ["esp32"]
-
-esp32_hall_ns = cg.esphome_ns.namespace("esp32_hall")
-ESP32HallSensor = esp32_hall_ns.class_(
-    "ESP32HallSensor", sensor.Sensor, cg.PollingComponent
+CONFIG_SCHEMA = cv.invalid(
+    "The esp32_hall component has been removed as of ESPHome 2025.7.0. See https://github.com/esphome/esphome/pull/9117 for details."
 )
-
-CONFIG_SCHEMA = sensor.sensor_schema(
-    ESP32HallSensor,
-    unit_of_measurement=UNIT_MICROTESLA,
-    icon=ICON_MAGNET,
-    accuracy_decimals=1,
-    state_class=STATE_CLASS_MEASUREMENT,
-).extend(cv.polling_component_schema("60s"))
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)

esphome/components/esp32_hosted/__init__.py

@@ -0,0 +1,101 @@
+import os
+
+from esphome import pins
+from esphome.components import esp32
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_CLK_PIN,
+    CONF_RESET_PIN,
+    CONF_VARIANT,
+    KEY_CORE,
+    KEY_FRAMEWORK_VERSION,
+)
+from esphome.core import CORE
+
+CODEOWNERS = ["@swoboda1337"]
+
+CONF_ACTIVE_HIGH = "active_high"
+CONF_CMD_PIN = "cmd_pin"
+CONF_D0_PIN = "d0_pin"
+CONF_D1_PIN = "d1_pin"
+CONF_D2_PIN = "d2_pin"
+CONF_D3_PIN = "d3_pin"
+CONF_SLOT = "slot"
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(CONF_VARIANT): cv.one_of(*esp32.VARIANTS, upper=True),
+            cv.Required(CONF_ACTIVE_HIGH): cv.boolean,
+            cv.Required(CONF_CLK_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_CMD_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_D0_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_D1_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_D2_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_D3_PIN): pins.internal_gpio_output_pin_number,
+            cv.Required(CONF_RESET_PIN): pins.internal_gpio_output_pin_number,
+            cv.Optional(CONF_SLOT, default=1): cv.int_range(min=0, max=1),
+        }
+    ),
+)
+
+
+async def to_code(config):
+    if config[CONF_ACTIVE_HIGH]:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH",
+            True,
+        )
+    else:
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_LOW",
+            True,
+        )
+    esp32.add_idf_sdkconfig_option(
+        "CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE",  # NOLINT
+        config[CONF_RESET_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_SLAVE_IDF_TARGET_{config[CONF_VARIANT]}",  # NOLINT
+        True,
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_SDIO_SLOT_{config[CONF_SLOT]}",
+        True,
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_{config[CONF_SLOT]}",
+        config[CONF_CLK_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_{config[CONF_SLOT]}",
+        config[CONF_CMD_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_{config[CONF_SLOT]}",
+        config[CONF_D0_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
+        config[CONF_D1_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
+        config[CONF_D2_PIN],
+    )
+    esp32.add_idf_sdkconfig_option(
+        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
+        config[CONF_D3_PIN],
+    )
+    esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_CUSTOM_SDIO_PINS", True)
+
+    framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
+    os.environ["ESP_IDF_VERSION"] = f"{framework_ver.major}.{framework_ver.minor}"
+    esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.10.2")
+    esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")
+    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.0.11")
+    esp32.add_extra_script(
+        "post",
+        "esp32_hosted.py",
+        os.path.join(os.path.dirname(__file__), "esp32_hosted.py.script"),
+    )

esphome/components/esp32_hosted/esp32_hosted.py.script

@@ -0,0 +1,12 @@
+# pylint: disable=E0602
+Import("env")  # noqa
+
+# Workaround whole archive issue
+if "__LIB_DEPS" in env and "libespressif__esp_hosted.a" in env["__LIB_DEPS"]:
+    env.Append(
+        LINKFLAGS=[
+            "-Wl,--whole-archive",
+            env["BUILD_DIR"] + "/esp-idf/espressif__esp_hosted/libespressif__esp_hosted.a",
+            "-Wl,--no-whole-archive",
+        ]
+    )

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -168,6 +168,8 @@ void ESP32ImprovComponent::loop() {
     case improv::STATE_PROVISIONED: {
       this->incoming_data_.clear();
       this->set_status_indicator_state_(false);
+      // Provisioning complete, no further loop execution needed
+      this->disable_loop();
       break;
     }
   }
@@ -254,6 +256,7 @@ void ESP32ImprovComponent::start() {
 
   ESP_LOGD(TAG, "Setting Improv to start");
   this->should_start_ = true;
+  this->enable_loop();
 }
 
 void ESP32ImprovComponent::stop() {

esphome/components/esp32_rmt/__init__.py

@@ -1,48 +1,8 @@
-import esphome.codegen as cg
 from esphome.components import esp32
 import esphome.config_validation as cv
-from esphome.const import KEY_CORE, KEY_FRAMEWORK_VERSION
-from esphome.core import CORE
 
 CODEOWNERS = ["@jesserockz"]
 
-RMT_TX_CHANNELS = {
-    esp32.const.VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7],
-    esp32.const.VARIANT_ESP32S2: [0, 1, 2, 3],
-    esp32.const.VARIANT_ESP32S3: [0, 1, 2, 3],
-    esp32.const.VARIANT_ESP32C3: [0, 1],
-    esp32.const.VARIANT_ESP32C6: [0, 1],
-    esp32.const.VARIANT_ESP32H2: [0, 1],
-}
-
-RMT_RX_CHANNELS = {
-    esp32.const.VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7],
-    esp32.const.VARIANT_ESP32S2: [0, 1, 2, 3],
-    esp32.const.VARIANT_ESP32S3: [4, 5, 6, 7],
-    esp32.const.VARIANT_ESP32C3: [2, 3],
-    esp32.const.VARIANT_ESP32C6: [2, 3],
-    esp32.const.VARIANT_ESP32H2: [2, 3],
-}
-
-rmt_channel_t = cg.global_ns.enum("rmt_channel_t")
-RMT_CHANNEL_ENUMS = {
-    0: rmt_channel_t.RMT_CHANNEL_0,
-    1: rmt_channel_t.RMT_CHANNEL_1,
-    2: rmt_channel_t.RMT_CHANNEL_2,
-    3: rmt_channel_t.RMT_CHANNEL_3,
-    4: rmt_channel_t.RMT_CHANNEL_4,
-    5: rmt_channel_t.RMT_CHANNEL_5,
-    6: rmt_channel_t.RMT_CHANNEL_6,
-    7: rmt_channel_t.RMT_CHANNEL_7,
-}
-
-
-def use_new_rmt_driver():
-    framework_version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
-    if CORE.using_esp_idf and framework_version >= cv.Version(5, 0, 0):
-        return True
-    return False
-
 
 def validate_clock_resolution():
     def _validator(value):
@@ -60,21 +20,3 @@ def validate_clock_resolution():
         return value
 
     return _validator
-
-
-def validate_rmt_channel(*, tx: bool):
-    rmt_channels = RMT_TX_CHANNELS if tx else RMT_RX_CHANNELS
-
-    def _validator(value):
-        cv.only_on_esp32(value)
-        value = cv.int_(value)
-        variant = esp32.get_esp32_variant()
-        if variant not in rmt_channels:
-            raise cv.Invalid(f"ESP32 variant {variant} does not support RMT.")
-        if value not in rmt_channels[variant]:
-            raise cv.Invalid(
-                f"RMT channel {value} does not support {'transmitting' if tx else 'receiving'} for ESP32 variant {variant}."
-            )
-        return cv.enum(RMT_CHANNEL_ENUMS)(value)
-
-    return _validator