Merge pull request #8746 from esphome/bump-2025.4.2

2025.4.2

.dockerignore

@@ -114,5 +114,4 @@ config/
 examples/
 Dockerfile
 .git/
-tests/
-.*
+tests/build/

.github/actions/build-image/action.yaml

@@ -1,11 +1,15 @@
 name: Build Image
 inputs:
+  platform:
+    description: "Platform to build for"
+    required: true
+    example: "linux/amd64"
   target:
     description: "Target to build"
     required: true
     example: "docker"
-  build_type:
-    description: "Build type"
+  baseimg:
+    description: "Base image type"
     required: true
     example: "docker"
   suffix:
@@ -15,11 +19,6 @@ inputs:
     description: "Version to build"
     required: true
     example: "2023.12.0"
-  base_os:
-    description: "Base OS to use"
-    required: false
-    default: "debian"
-    example: "debian"
 runs:
   using: "composite"
   steps:
@@ -47,52 +46,52 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@v6.16.0
+      uses: docker/build-push-action@v6.15.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
       with:
         context: .
         file: ./docker/Dockerfile
+        platforms: ${{ inputs.platform }}
         target: ${{ inputs.target }}
         cache-from: type=gha
         cache-to: ${{ steps.cache-to.outputs.value }}
         build-args: |
-          BUILD_TYPE=${{ inputs.build_type }}
+          BASEIMGTYPE=${{ inputs.baseimg }}
           BUILD_VERSION=${{ inputs.version }}
-          BUILD_OS=${{ inputs.base_os }}
         outputs: |
           type=image,name=ghcr.io/${{ steps.tags.outputs.image_name }},push-by-digest=true,name-canonical=true,push=true
 
     - name: Export ghcr digests
       shell: bash
       run: |
-        mkdir -p /tmp/digests/${{ inputs.build_type }}/ghcr
+        mkdir -p /tmp/digests/${{ inputs.target }}/ghcr
         digest="${{ steps.build-ghcr.outputs.digest }}"
-        touch "/tmp/digests/${{ inputs.build_type }}/ghcr/${digest#sha256:}"
+        touch "/tmp/digests/${{ inputs.target }}/ghcr/${digest#sha256:}"
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@v6.16.0
+      uses: docker/build-push-action@v6.15.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
       with:
         context: .
         file: ./docker/Dockerfile
+        platforms: ${{ inputs.platform }}
         target: ${{ inputs.target }}
         cache-from: type=gha
         cache-to: ${{ steps.cache-to.outputs.value }}
         build-args: |
-          BUILD_TYPE=${{ inputs.build_type }}
+          BASEIMGTYPE=${{ inputs.baseimg }}
           BUILD_VERSION=${{ inputs.version }}
-          BUILD_OS=${{ inputs.base_os }}
         outputs: |
           type=image,name=docker.io/${{ steps.tags.outputs.image_name }},push-by-digest=true,name-canonical=true,push=true
 
     - name: Export dockerhub digests
       shell: bash
       run: |
-        mkdir -p /tmp/digests/${{ inputs.build_type }}/dockerhub
+        mkdir -p /tmp/digests/${{ inputs.target }}/dockerhub
         digest="${{ steps.build-dockerhub.outputs.digest }}"
-        touch "/tmp/digests/${{ inputs.build_type }}/dockerhub/${digest#sha256:}"
+        touch "/tmp/digests/${{ inputs.target }}/dockerhub/${digest#sha256:}"

.github/actions/restore-python/action.yml

@@ -17,7 +17,7 @@ runs:
   steps:
     - name: Set up Python ${{ inputs.python-version }}
       id: python
-      uses: actions/setup-python@v5.6.0
+      uses: actions/setup-python@v5.5.0
       with:
         python-version: ${{ inputs.python-version }}
     - name: Restore Python virtual environment
@@ -34,7 +34,7 @@ runs:
         python -m venv venv
         source venv/bin/activate
         python --version
-        pip install -r requirements.txt -r requirements_test.txt
+        pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
         pip install -e .
     - name: Create Python virtual environment
       if: steps.cache-venv.outputs.cache-hit != 'true' && runner.os == 'Windows'
@@ -43,5 +43,5 @@ runs:
         python -m venv venv
         ./venv/Scripts/activate
         python --version
-        pip install -r requirements.txt -r requirements_test.txt
+        pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
         pip install -e .

.github/dependabot.yml

@@ -17,6 +17,7 @@ updates:
       docker-actions:
         applies-to: version-updates
         patterns:
+          - "docker/setup-qemu-action"
           - "docker/login-action"
           - "docker/setup-buildx-action"
   - package-ecosystem: github-actions

.github/workflows/ci-api-proto.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4.1.7
       - name: Set up Python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: "3.11"
 

.github/workflows/ci-docker.yml

@@ -37,15 +37,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: ["ubuntu-24.04", "ubuntu-24.04-arm"]
-        build_type:
-          - "ha-addon"
-          - "docker"
-          # - "lint"
+        os: ["ubuntu-latest", "ubuntu-24.04-arm"]
+        build_type: ["ha-addon", "docker", "lint"]
     steps:
       - uses: actions/checkout@v4.1.7
       - name: Set up Python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: "3.9"
       - name: Set up Docker Buildx

.github/workflows/ci.yml

@@ -39,10 +39,10 @@ jobs:
         uses: actions/checkout@v4.1.7
       - name: Generate cache-key
         id: cache-key
-        run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt') }}" >> $GITHUB_OUTPUT
+        run: echo key="${{ hashFiles('requirements.txt', 'requirements_optional.txt', 'requirements_test.txt') }}" >> $GITHUB_OUTPUT
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
       - name: Restore Python virtual environment
@@ -58,7 +58,7 @@ jobs:
           python -m venv venv
           . venv/bin/activate
           python --version
-          pip install -r requirements.txt -r requirements_test.txt
+          pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
           pip install -e .
 
   ruff:
@@ -165,7 +165,6 @@ jobs:
           . venv/bin/activate
           script/ci-custom.py
           script/build_codeowners.py --check
-          script/build_language_schema.py --check
 
   pytest:
     name: Run pytest
@@ -221,7 +220,7 @@ jobs:
           . venv/bin/activate
           pytest -vv --cov-report=xml --tb=native tests
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5.4.2
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
 

.github/workflows/release.yml

@@ -53,7 +53,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4.1.7
       - name: Set up Python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: "3.x"
       - name: Set up python environment
@@ -68,31 +68,31 @@ jobs:
         uses: pypa/gh-action-pypi-publish@v1.12.4
 
   deploy-docker:
-    name: Build ESPHome ${{ matrix.platform.arch }}
+    name: Build ESPHome ${{ matrix.platform }}
     if: github.repository == 'esphome/esphome'
     permissions:
       contents: read
       packages: write
-    runs-on: ${{ matrix.platform.os }}
+    runs-on: ubuntu-latest
     needs: [init]
     strategy:
       fail-fast: false
       matrix:
         platform:
-          - arch: amd64
-            os: "ubuntu-24.04"
-          - arch: arm64
-            os: "ubuntu-24.04-arm"
-
+          - linux/amd64
+          - linux/arm64
     steps:
       - uses: actions/checkout@v4.1.7
       - name: Set up Python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: "3.9"
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3.10.0
+      - name: Set up QEMU
+        if: matrix.platform != 'linux/amd64'
+        uses: docker/setup-qemu-action@v3.6.0
 
       - name: Log in to docker hub
         uses: docker/login-action@v3.4.0
@@ -109,36 +109,45 @@ jobs:
       - name: Build docker
         uses: ./.github/actions/build-image
         with:
-          target: final
-          build_type: docker
+          platform: ${{ matrix.platform }}
+          target: docker
+          baseimg: docker
           suffix: ""
           version: ${{ needs.init.outputs.tag }}
 
       - name: Build ha-addon
         uses: ./.github/actions/build-image
         with:
-          target: final
-          build_type: ha-addon
+          platform: ${{ matrix.platform }}
+          target: hassio
+          baseimg: hassio
           suffix: "hassio"
           version: ${{ needs.init.outputs.tag }}
 
-      # - name: Build lint
-      #   uses: ./.github/actions/build-image
-      #   with:
-      #     target: lint
-      #     build_type: lint
-      #     suffix: lint
-      #     version: ${{ needs.init.outputs.tag }}
+      - name: Build lint
+        uses: ./.github/actions/build-image
+        with:
+          platform: ${{ matrix.platform }}
+          target: lint
+          baseimg: docker
+          suffix: lint
+          version: ${{ needs.init.outputs.tag }}
+
+      - name: Sanitize platform name
+        id: sanitize
+        run: |
+          echo "${{ matrix.platform }}" | sed 's|/|-|g' > /tmp/platform
+          echo name=$(cat /tmp/platform) >> $GITHUB_OUTPUT
 
       - name: Upload digests
         uses: actions/upload-artifact@v4.6.2
         with:
-          name: digests-${{ matrix.platform.arch }}
+          name: digests-${{ steps.sanitize.outputs.name }}
           path: /tmp/digests
           retention-days: 1
 
   deploy-manifest:
-    name: Publish ESPHome ${{ matrix.image.build_type }} to ${{ matrix.registry }}
+    name: Publish ESPHome ${{ matrix.image.title }} to ${{ matrix.registry }}
     runs-on: ubuntu-latest
     needs:
       - init
@@ -151,12 +160,15 @@ jobs:
       fail-fast: false
       matrix:
         image:
-          - build_type: "docker"
-            suffix: ""
-          - build_type: "ha-addon"
+          - title: "ha-addon"
+            target: "hassio"
             suffix: "hassio"
-            # - build_type: "lint"
-            #   suffix: "lint"
+          - title: "docker"
+            target: "docker"
+            suffix: ""
+          - title: "lint"
+            target: "lint"
+            suffix: "lint"
         registry:
           - ghcr
           - dockerhub
@@ -164,7 +176,7 @@ jobs:
       - uses: actions/checkout@v4.1.7
 
       - name: Download digests
-        uses: actions/download-artifact@v4.3.0
+        uses: actions/download-artifact@v4.2.1
         with:
           pattern: digests-*
           path: /tmp/digests
@@ -200,7 +212,7 @@ jobs:
           done
 
       - name: Create manifest list and push
-        working-directory: /tmp/digests/${{ matrix.image.build_type }}/${{ matrix.registry }}
+        working-directory: /tmp/digests/${{ matrix.image.target }}/${{ matrix.registry }}
         run: |
           docker buildx imagetools create $(jq -Rcnr 'inputs | . / "," | map("-t " + .) | join(" ")' <<< "${{ steps.tags.outputs.tags}}") \
             $(printf '${{ steps.tags.outputs.image }}@sha256:%s ' *)

.github/workflows/sync-device-classes.yml

@@ -22,7 +22,7 @@ jobs:
           path: lib/home-assistant
 
       - name: Setup Python
-        uses: actions/setup-python@v5.6.0
+        uses: actions/setup-python@v5.5.0
         with:
           python-version: 3.12
 

CODEOWNERS

@@ -98,7 +98,6 @@ esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
 esphome/components/color_temperature/* @jesserockz
 esphome/components/combination/* @Cat-Ion @kahrendt
-esphome/components/const/* @esphome/core
 esphome/components/coolix/* @glmnet
 esphome/components/copy/* @OttoWinter
 esphome/components/cover/* @esphome/core
@@ -251,7 +250,6 @@ esphome/components/ltr501/* @latonita
 esphome/components/ltr_als_ps/* @latonita
 esphome/components/lvgl/* @clydebarrow
 esphome/components/m5stack_8angle/* @rnauber
-esphome/components/mapping/* @clydebarrow
 esphome/components/matrix_keypad/* @ssieb
 esphome/components/max17043/* @blacknell
 esphome/components/max31865/* @DAVe3283
@@ -326,7 +324,6 @@ esphome/components/pcf8563/* @KoenBreeman
 esphome/components/pid/* @OttoWinter
 esphome/components/pipsolar/* @andreashergert1984
 esphome/components/pm1006/* @habbie
-esphome/components/pm2005/* @andrewjswan
 esphome/components/pmsa003i/* @sjtrny
 esphome/components/pmwcs3/* @SeByDocKy
 esphome/components/pn532/* @OttoWinter @jesserockz

docker/Dockerfile

@@ -1,54 +1,131 @@
-ARG BUILD_VERSION=dev
-ARG BUILD_OS=alpine
-ARG BUILD_BASE_VERSION=2025.04.0
-ARG BUILD_TYPE=docker
+# Build these with the build.py script
+# Example:
+#   python3 docker/build.py --tag dev --arch amd64 --build-type docker build
 
-FROM ghcr.io/esphome/docker-base:${BUILD_OS}-${BUILD_BASE_VERSION} AS base-source-docker
-FROM ghcr.io/esphome/docker-base:${BUILD_OS}-ha-addon-${BUILD_BASE_VERSION} AS base-source-ha-addon
+# One of "docker", "hassio"
+ARG BASEIMGTYPE=docker
 
-ARG BUILD_TYPE
-FROM base-source-${BUILD_TYPE} AS base
 
-RUN git config --system --add safe.directory "*"
+# https://github.com/hassio-addons/addon-debian-base/releases
+FROM ghcr.io/hassio-addons/debian-base:7.2.0 AS base-hassio
+# https://hub.docker.com/_/debian?tab=tags&page=1&name=bookworm
+FROM debian:12.2-slim AS base-docker
 
-RUN pip install uv==0.6.14
+FROM base-${BASEIMGTYPE} AS base
 
-COPY requirements.txt /
+
+ARG TARGETARCH
+ARG TARGETVARIANT
+
+
+# Note that --break-system-packages is used below because
+# https://peps.python.org/pep-0668/ added a safety check that prevents
+# installing packages with the same name as a system package. This is
+# not a problem for us because we are not concerned about overwriting
+# system packages because we are running in an isolated container.
 
 RUN \
-    uv pip install --no-cache-dir \
-    -r /requirements.txt
+    apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        python3-pip=23.0.1+dfsg-1 \
+        python3-setuptools=66.1.1-1+deb12u1 \
+        python3-venv=3.11.2-1+b1 \
+        python3-wheel=0.38.4-2 \
+        iputils-ping=3:20221126-1+deb12u1 \
+        git=1:2.39.5-0+deb12u2 \
+        curl=7.88.1-10+deb12u12 \
+        openssh-client=1:9.2p1-2+deb12u5 \
+        python3-cffi=1.15.1-5 \
+        libcairo2=1.16.0-7 \
+        libmagic1=1:5.44-3 \
+        patch=2.7.6-7 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+ENV \
+  # Fix click python3 lang warning https://click.palletsprojects.com/en/7.x/python3/
+  LANG=C.UTF-8 LC_ALL=C.UTF-8 \
+  # Store globally installed pio libs in /piolibs
+  PLATFORMIO_GLOBALLIB_DIR=/piolibs
 
 RUN \
-    platformio settings set enable_telemetry No \
+    pip3 install \
+    --break-system-packages --no-cache-dir \
+    # Keep platformio version in sync with requirements.txt
+    platformio==6.1.18 \
+    # Change some platformio settings
+    && platformio settings set enable_telemetry No \
     && platformio settings set check_platformio_interval 1000000 \
     && mkdir -p /piolibs
 
+
+# First install requirements to leverage caching when requirements don't change
+# tmpfs is for https://github.com/rust-lang/cargo/issues/8719
+
+COPY requirements.txt requirements_optional.txt /
+RUN --mount=type=tmpfs,target=/root/.cargo <<END-OF-RUN
+# Fail on any non-zero status
+set -e
+
+# install build tools in case wheels are not available
+BUILD_DEPS="
+    build-essential=12.9
+    python3-dev=3.11.2-1+b1
+    zlib1g-dev=1:1.2.13.dfsg-1
+    libjpeg-dev=1:2.1.5-2
+    libfreetype-dev=2.12.1+dfsg-5+deb12u4
+    libssl-dev=3.0.15-1~deb12u1
+    libffi-dev=3.4.4-1
+    cargo=0.66.0+ds1-1
+    pkg-config=1.8.1-1
+"
+LIB_DEPS="
+    libtiff6=4.5.0-6+deb12u1
+    libopenjp2-7=2.5.0-2+deb12u1
+"
+if [ "$TARGETARCH$TARGETVARIANT" = "arm64" ]
+then
+    apt-get update
+    apt-get install -y --no-install-recommends $BUILD_DEPS $LIB_DEPS
+fi
+
+CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse CARGO_HOME=/root/.cargo
+pip3 install --break-system-packages --no-cache-dir -r /requirements.txt -r /requirements_optional.txt
+
+if [ "$TARGETARCH$TARGETVARIANT" = "arm64" ]
+then
+    apt-get remove -y --purge --auto-remove $BUILD_DEPS
+    rm -rf /tmp/* /var/{cache,log}/* /var/lib/apt/lists/*
+fi
+END-OF-RUN
+
+
 COPY script/platformio_install_deps.py platformio.ini /
 RUN /platformio_install_deps.py /platformio.ini --libraries
 
-ARG BUILD_VERSION
-
-LABEL \
-    org.opencontainers.image.authors="The ESPHome Authors" \
-    org.opencontainers.image.title="ESPHome" \
-    org.opencontainers.image.description="ESPHome is a system to configure your microcontrollers by simple yet powerful configuration files and control them remotely through Home Automation systems" \
-    org.opencontainers.image.url="https://esphome.io/" \
-    org.opencontainers.image.documentation="https://esphome.io/" \
-    org.opencontainers.image.source="https://github.com/esphome/esphome" \
-    org.opencontainers.image.licenses="ESPHome" \
-    org.opencontainers.image.version=${BUILD_VERSION}
+# Avoid unsafe git error when container user and file config volume permissions don't match
+RUN git config --system --add safe.directory '*'
 
 
 # ======================= docker-type image =======================
-FROM base AS base-docker
+FROM base AS docker
+
+# Copy esphome and install
+COPY . /esphome
+RUN pip3 install --break-system-packages --no-cache-dir -e /esphome
+
+# Settings for dashboard
+ENV USERNAME="" PASSWORD=""
 
 # Expose the dashboard to Docker
 EXPOSE 6052
 
 # Run healthcheck (heartbeat)
 HEALTHCHECK --interval=30s --timeout=30s \
-    CMD curl --fail http://localhost:6052/version -A "HealthCheck" || exit 1
+  CMD curl --fail http://localhost:6052/version -A "HealthCheck" || exit 1
 
 COPY docker/docker_entrypoint.sh /entrypoint.sh
 
@@ -62,13 +139,43 @@ ENTRYPOINT ["/entrypoint.sh"]
 CMD ["dashboard", "/config"]
 
 
-# ======================= ha-addon-type image =======================
-FROM base AS base-ha-addon
+ARG BUILD_VERSION=dev
+
+# Labels
+LABEL \
+    org.opencontainers.image.authors="The ESPHome Authors" \
+    org.opencontainers.image.title="ESPHome" \
+    org.opencontainers.image.description="ESPHome is a system to configure your microcontrollers by simple yet powerful configuration files and control them remotely through Home Automation systems" \
+    org.opencontainers.image.url="https://esphome.io/" \
+    org.opencontainers.image.documentation="https://esphome.io/" \
+    org.opencontainers.image.source="https://github.com/esphome/esphome" \
+    org.opencontainers.image.licenses="ESPHome" \
+    org.opencontainers.image.version=${BUILD_VERSION}
+
+
+# ======================= hassio-type image =======================
+FROM base AS hassio
+
+RUN \
+    apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        nginx-light=1.22.1-9+deb12u1 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+ARG BUILD_VERSION=dev
 
 # Copy root filesystem
 COPY docker/ha-addon-rootfs/ /
 
-ARG BUILD_VERSION
+# Copy esphome and install
+COPY . /esphome
+RUN pip3 install --break-system-packages --no-cache-dir -e /esphome
+
+# Labels
 LABEL \
     io.hass.name="ESPHome" \
     io.hass.description="ESPHome is a system to configure your microcontrollers by simple yet powerful configuration files and control them remotely through Home Automation systems" \
@@ -76,9 +183,35 @@ LABEL \
     io.hass.version="${BUILD_VERSION}"
     # io.hass.arch is inherited from addon-debian-base
 
-ARG BUILD_TYPE
-FROM base-${BUILD_TYPE} AS final
 
-# Copy esphome and install
-COPY . /esphome
-RUN uv pip install --no-cache-dir -e /esphome
+
+
+# ======================= lint-type image =======================
+FROM base AS lint
+
+ENV \
+  PLATFORMIO_CORE_DIR=/esphome/.temp/platformio
+
+RUN \
+    curl -L https://apt.llvm.org/llvm-snapshot.gpg.key -o /etc/apt/trusted.gpg.d/apt.llvm.org.asc \
+    && echo "deb http://apt.llvm.org/bookworm/ llvm-toolchain-bookworm-18 main" > /etc/apt/sources.list.d/llvm.sources.list \
+    && apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        clang-format-13=1:13.0.1-11+b2 \
+        patch=2.7.6-7 \
+        software-properties-common=0.99.30-4.1~deb12u1 \
+        nano=7.2-1+deb12u1 \
+        build-essential=12.9 \
+        python3-dev=3.11.2-1+b1 \
+        clang-tidy-18=1:18.1.8~++20240731024826+3b5b5c1ec4a3-1~exp1~20240731144843.145 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+COPY requirements_test.txt /
+RUN pip3 install --break-system-packages --no-cache-dir -r /requirements_test.txt
+
+VOLUME ["/esphome"]
+WORKDIR /esphome

docker/build.py

@@ -54,7 +54,7 @@ manifest_parser = subparsers.add_parser(
 class DockerParams:
     build_to: str
     manifest_to: str
-    build_type: str
+    baseimgtype: str
     platform: str
     target: str
 
@@ -66,19 +66,24 @@ class DockerParams:
             TYPE_LINT: "esphome/esphome-lint",
         }[build_type]
         build_to = f"{prefix}-{arch}"
+        baseimgtype = {
+            TYPE_DOCKER: "docker",
+            TYPE_HA_ADDON: "hassio",
+            TYPE_LINT: "docker",
+        }[build_type]
         platform = {
             ARCH_AMD64: "linux/amd64",
             ARCH_AARCH64: "linux/arm64",
         }[arch]
         target = {
-            TYPE_DOCKER: "final",
-            TYPE_HA_ADDON: "final",
+            TYPE_DOCKER: "docker",
+            TYPE_HA_ADDON: "hassio",
             TYPE_LINT: "lint",
         }[build_type]
         return cls(
             build_to=build_to,
             manifest_to=prefix,
-            build_type=build_type,
+            baseimgtype=baseimgtype,
             platform=platform,
             target=target,
         )
@@ -140,7 +145,7 @@ def main():
             "buildx",
             "build",
             "--build-arg",
-            f"BUILD_TYPE={params.build_type}",
+            f"BASEIMGTYPE={params.baseimgtype}",
             "--build-arg",
             f"BUILD_VERSION={args.tag}",
             "--cache-from",

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -114,14 +114,13 @@ void IRAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
     // fully off, disable output immediately
     this->gate_pin.digital_write(false);
   } else {
-    auto min_us = this->cycle_time_us * this->min_power / 1000;
     if (this->method == DIM_METHOD_TRAILING) {
       this->enable_time_us = 1;  // cannot be 0
-      // calculate time until disable in µs with integer arithmetic and take into account min_power
-      this->disable_time_us = std::max((uint32_t) 10, this->value * (this->cycle_time_us - min_us) / 65535 + min_us);
+      this->disable_time_us = std::max((uint32_t) 10, this->value * this->cycle_time_us / 65535);
     } else {
       // calculate time until enable in µs: (1.0-value)*cycle_time, but with integer arithmetic
       // also take into account min_power
+      auto min_us = this->cycle_time_us * this->min_power / 1000;
       this->enable_time_us = std::max((uint32_t) 1, ((65535 - this->value) * (this->cycle_time_us - min_us)) / 65535);
 
       if (this->method == DIM_METHOD_LEADING_PULSE) {

esphome/components/analog_threshold/analog_threshold_binary_sensor.cpp

@@ -14,8 +14,7 @@ void AnalogThresholdBinarySensor::setup() {
   if (std::isnan(sensor_value)) {
     this->publish_initial_state(false);
   } else {
-    this->publish_initial_state(sensor_value >=
-                                (this->lower_threshold_.value() + this->upper_threshold_.value()) / 2.0f);
+    this->publish_initial_state(sensor_value >= (this->lower_threshold_ + this->upper_threshold_) / 2.0f);
   }
 }
 
@@ -25,8 +24,7 @@ void AnalogThresholdBinarySensor::set_sensor(sensor::Sensor *analog_sensor) {
   this->sensor_->add_on_state_callback([this](float sensor_value) {
     // if there is an invalid sensor reading, ignore the change and keep the current state
     if (!std::isnan(sensor_value)) {
-      this->publish_state(sensor_value >=
-                          (this->state ? this->lower_threshold_.value() : this->upper_threshold_.value()));
+      this->publish_state(sensor_value >= (this->state ? this->lower_threshold_ : this->upper_threshold_));
     }
   });
 }
@@ -34,8 +32,8 @@ void AnalogThresholdBinarySensor::set_sensor(sensor::Sensor *analog_sensor) {
 void AnalogThresholdBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "Analog Threshold Binary Sensor", this);
   LOG_SENSOR("  ", "Sensor", this->sensor_);
-  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_.value());
-  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_.value());
+  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_);
+  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_);
 }
 
 }  // namespace analog_threshold

esphome/components/analog_threshold/analog_threshold_binary_sensor.h

@@ -15,13 +15,14 @@ class AnalogThresholdBinarySensor : public Component, public binary_sensor::Bina
   float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_sensor(sensor::Sensor *analog_sensor);
-  template<typename T> void set_upper_threshold(T upper_threshold) { this->upper_threshold_ = upper_threshold; }
-  template<typename T> void set_lower_threshold(T lower_threshold) { this->lower_threshold_ = lower_threshold; }
+  void set_upper_threshold(float threshold) { this->upper_threshold_ = threshold; }
+  void set_lower_threshold(float threshold) { this->lower_threshold_ = threshold; }
 
  protected:
   sensor::Sensor *sensor_{nullptr};
-  TemplatableValue<float> upper_threshold_{};
-  TemplatableValue<float> lower_threshold_{};
+
+  float upper_threshold_;
+  float lower_threshold_;
 };
 
 }  // namespace analog_threshold

esphome/components/analog_threshold/binary_sensor.py

@@ -18,11 +18,11 @@ CONFIG_SCHEMA = (
         {
             cv.Required(CONF_SENSOR_ID): cv.use_id(sensor.Sensor),
             cv.Required(CONF_THRESHOLD): cv.Any(
-                cv.templatable(cv.float_),
+                cv.float_,
                 cv.Schema(
                     {
-                        cv.Required(CONF_UPPER): cv.templatable(cv.float_),
-                        cv.Required(CONF_LOWER): cv.templatable(cv.float_),
+                        cv.Required(CONF_UPPER): cv.float_,
+                        cv.Required(CONF_LOWER): cv.float_,
                     }
                 ),
             ),
@@ -39,11 +39,9 @@ async def to_code(config):
     sens = await cg.get_variable(config[CONF_SENSOR_ID])
     cg.add(var.set_sensor(sens))
 
-    if isinstance(config[CONF_THRESHOLD], dict):
-        lower = await cg.templatable(config[CONF_THRESHOLD][CONF_LOWER], [], float)
-        upper = await cg.templatable(config[CONF_THRESHOLD][CONF_UPPER], [], float)
+    if isinstance(config[CONF_THRESHOLD], float):
+        cg.add(var.set_upper_threshold(config[CONF_THRESHOLD]))
+        cg.add(var.set_lower_threshold(config[CONF_THRESHOLD]))
     else:
-        lower = await cg.templatable(config[CONF_THRESHOLD], [], float)
-        upper = lower
-    cg.add(var.set_upper_threshold(upper))
-    cg.add(var.set_lower_threshold(lower))
+        cg.add(var.set_upper_threshold(config[CONF_THRESHOLD][CONF_UPPER]))
+        cg.add(var.set_lower_threshold(config[CONF_THRESHOLD][CONF_LOWER]))

esphome/components/api/__init__.py

@@ -82,19 +82,6 @@ ACTIONS_SCHEMA = automation.validate_automation(
     ),
 )
 
-ENCRYPTION_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_KEY): validate_encryption_key,
-    }
-)
-
-
-def _encryption_schema(config):
-    if config is None:
-        config = {}
-    return ENCRYPTION_SCHEMA(config)
-
-
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -108,7 +95,11 @@ CONFIG_SCHEMA = cv.All(
                 CONF_SERVICES, group_of_exclusion=CONF_ACTIONS
             ): ACTIONS_SCHEMA,
             cv.Exclusive(CONF_ACTIONS, group_of_exclusion=CONF_ACTIONS): ACTIONS_SCHEMA,
-            cv.Optional(CONF_ENCRYPTION): _encryption_schema,
+            cv.Optional(CONF_ENCRYPTION): cv.Schema(
+                {
+                    cv.Required(CONF_KEY): validate_encryption_key,
+                }
+            ),
             cv.Optional(CONF_ON_CLIENT_CONNECTED): automation.validate_automation(
                 single=True
             ),
@@ -160,17 +151,9 @@ async def to_code(config):
             config[CONF_ON_CLIENT_DISCONNECTED],
         )
 
-    if (encryption_config := config.get(CONF_ENCRYPTION, None)) is not None:
-        if key := encryption_config.get(CONF_KEY):
-            decoded = base64.b64decode(key)
-            cg.add(var.set_noise_psk(list(decoded)))
-        else:
-            # No key provided, but encryption desired
-            # This will allow a plaintext client to provide a noise key,
-            # send it to the device, and then switch to noise.
-            # The key will be saved in flash and used for future connections
-            # and plaintext disabled. Only a factory reset can remove it.
-            cg.add_define("USE_API_PLAINTEXT")
+    if encryption_config := config.get(CONF_ENCRYPTION):
+        decoded = base64.b64decode(encryption_config[CONF_KEY])
+        cg.add(var.set_noise_psk(list(decoded)))
         cg.add_define("USE_API_NOISE")
         cg.add_library("esphome/noise-c", "0.1.6")
     else:

esphome/components/api/api.proto

@@ -31,7 +31,6 @@ service APIConnection {
     option (needs_authentication) = false;
   }
   rpc execute_service (ExecuteServiceRequest) returns (void) {}
-  rpc noise_encryption_set_key (NoiseEncryptionSetKeyRequest) returns (NoiseEncryptionSetKeyResponse) {}
 
   rpc cover_command (CoverCommandRequest) returns (void) {}
   rpc fan_command (FanCommandRequest) returns (void) {}
@@ -231,9 +230,6 @@ message DeviceInfoResponse {
 
   // The Bluetooth mac address of the device. For example "AC:BC:32:89:0E:AA"
   string bluetooth_mac_address = 18;
-
-  // Supports receiving and saving api encryption key
-  bool api_encryption_supported = 19;
 }
 
 message ListEntitiesRequest {
@@ -658,23 +654,6 @@ message SubscribeLogsResponse {
   bool send_failed = 4;
 }
 
-// ==================== NOISE ENCRYPTION ====================
-message NoiseEncryptionSetKeyRequest {
-  option (id) = 124;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_API_NOISE";
-
-  bytes key = 1;
-}
-
-message NoiseEncryptionSetKeyResponse {
-  option (id) = 125;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_API_NOISE";
-
-  bool success = 1;
-}
-
 // ==================== HOMEASSISTANT.SERVICE ====================
 message SubscribeHomeassistantServicesRequest {
   option (id) = 34;

esphome/components/api/api_connection.cpp

@@ -62,14 +62,7 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
     : parent_(parent), deferred_message_queue_(this), initial_state_iterator_(this), list_entities_iterator_(this) {
   this->proto_write_buffer_.reserve(64);
 
-#if defined(USE_API_PLAINTEXT) && defined(USE_API_NOISE)
-  auto noise_ctx = parent->get_noise_ctx();
-  if (noise_ctx->has_psk()) {
-    this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), noise_ctx)};
-  } else {
-    this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
-  }
-#elif defined(USE_API_PLAINTEXT)
+#if defined(USE_API_PLAINTEXT)
   this->helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
 #elif defined(USE_API_NOISE)
   this->helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
@@ -1855,9 +1848,6 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
 #ifdef USE_VOICE_ASSISTANT
   resp.legacy_voice_assistant_version = voice_assistant::global_voice_assistant->get_legacy_version();
   resp.voice_assistant_feature_flags = voice_assistant::global_voice_assistant->get_feature_flags();
-#endif
-#ifdef USE_API_NOISE
-  resp.api_encryption_supported = true;
 #endif
   return resp;
 }
@@ -1879,26 +1869,6 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
     ESP_LOGV(TAG, "Could not find matching service!");
   }
 }
-#ifdef USE_API_NOISE
-NoiseEncryptionSetKeyResponse APIConnection::noise_encryption_set_key(const NoiseEncryptionSetKeyRequest &msg) {
-  psk_t psk{};
-  NoiseEncryptionSetKeyResponse resp;
-  if (base64_decode(msg.key, psk.data(), msg.key.size()) != psk.size()) {
-    ESP_LOGW(TAG, "Invalid encryption key length");
-    resp.success = false;
-    return resp;
-  }
-
-  if (!this->parent_->save_noise_psk(psk, true)) {
-    ESP_LOGW(TAG, "Failed to save encryption key");
-    resp.success = false;
-    return resp;
-  }
-
-  resp.success = true;
-  return resp;
-}
-#endif
 void APIConnection::subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) {
   state_subs_at_ = 0;
 }

esphome/components/api/api_connection.h

@@ -300,9 +300,6 @@ class APIConnection : public APIServerConnection {
     return {};
   }
   void execute_service(const ExecuteServiceRequest &msg) override;
-#ifdef USE_API_NOISE
-  NoiseEncryptionSetKeyResponse noise_encryption_set_key(const NoiseEncryptionSetKeyRequest &msg) override;
-#endif
 
   bool is_authenticated() override { return this->connection_state_ == ConnectionState::AUTHENTICATED; }
   bool is_connection_setup() override {

esphome/components/api/api_noise_context.h

@@ -1,6 +1,6 @@
 #pragma once
-#include <array>
 #include <cstdint>
+#include <array>
 #include "esphome/core/defines.h"
 
 namespace esphome {
@@ -11,20 +11,11 @@ using psk_t = std::array<uint8_t, 32>;
 
 class APINoiseContext {
  public:
-  void set_psk(psk_t psk) {
-    this->psk_ = psk;
-    bool has_psk = false;
-    for (auto i : psk) {
-      has_psk |= i;
-    }
-    this->has_psk_ = has_psk;
-  }
-  const psk_t &get_psk() const { return this->psk_; }
-  bool has_psk() const { return this->has_psk_; }
+  void set_psk(psk_t psk) { psk_ = psk; }
+  const psk_t &get_psk() const { return psk_; }
 
  protected:
-  psk_t psk_{};
-  bool has_psk_{false};
+  psk_t psk_;
 };
 #endif  // USE_API_NOISE
 

esphome/components/api/api_pb2.cpp

@@ -792,10 +792,6 @@ bool DeviceInfoResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->voice_assistant_feature_flags = value.as_uint32();
       return true;
     }
-    case 19: {
-      this->api_encryption_supported = value.as_bool();
-      return true;
-    }
     default:
       return false;
   }
@@ -869,7 +865,6 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(17, this->voice_assistant_feature_flags);
   buffer.encode_string(16, this->suggested_area);
   buffer.encode_string(18, this->bluetooth_mac_address);
-  buffer.encode_bool(19, this->api_encryption_supported);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoResponse::dump_to(std::string &out) const {
@@ -951,10 +946,6 @@ void DeviceInfoResponse::dump_to(std::string &out) const {
   out.append("  bluetooth_mac_address: ");
   out.append("'").append(this->bluetooth_mac_address).append("'");
   out.append("\n");
-
-  out.append("  api_encryption_supported: ");
-  out.append(YESNO(this->api_encryption_supported));
-  out.append("\n");
   out.append("}");
 }
 #endif
@@ -3018,48 +3009,6 @@ void SubscribeLogsResponse::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
-bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
-  switch (field_id) {
-    case 1: {
-      this->key = value.as_string();
-      return true;
-    }
-    default:
-      return false;
-  }
-}
-void NoiseEncryptionSetKeyRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->key); }
-#ifdef HAS_PROTO_MESSAGE_DUMP
-void NoiseEncryptionSetKeyRequest::dump_to(std::string &out) const {
-  __attribute__((unused)) char buffer[64];
-  out.append("NoiseEncryptionSetKeyRequest {\n");
-  out.append("  key: ");
-  out.append("'").append(this->key).append("'");
-  out.append("\n");
-  out.append("}");
-}
-#endif
-bool NoiseEncryptionSetKeyResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1: {
-      this->success = value.as_bool();
-      return true;
-    }
-    default:
-      return false;
-  }
-}
-void NoiseEncryptionSetKeyResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->success); }
-#ifdef HAS_PROTO_MESSAGE_DUMP
-void NoiseEncryptionSetKeyResponse::dump_to(std::string &out) const {
-  __attribute__((unused)) char buffer[64];
-  out.append("NoiseEncryptionSetKeyResponse {\n");
-  out.append("  success: ");
-  out.append(YESNO(this->success));
-  out.append("\n");
-  out.append("}");
-}
-#endif
 void SubscribeHomeassistantServicesRequest::encode(ProtoWriteBuffer buffer) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeassistantServicesRequest::dump_to(std::string &out) const {

esphome/components/api/api_pb2.h

@@ -355,7 +355,6 @@ class DeviceInfoResponse : public ProtoMessage {
   uint32_t voice_assistant_feature_flags{0};
   std::string suggested_area{};
   std::string bluetooth_mac_address{};
-  bool api_encryption_supported{false};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -792,28 +791,6 @@ class SubscribeLogsResponse : public ProtoMessage {
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
-class NoiseEncryptionSetKeyRequest : public ProtoMessage {
- public:
-  std::string key{};
-  void encode(ProtoWriteBuffer buffer) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
-};
-class NoiseEncryptionSetKeyResponse : public ProtoMessage {
- public:
-  bool success{false};
-  void encode(ProtoWriteBuffer buffer) const override;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
 class SubscribeHomeassistantServicesRequest : public ProtoMessage {
  public:
   void encode(ProtoWriteBuffer buffer) const override;

esphome/components/api/api_pb2_service.cpp

@@ -179,16 +179,6 @@ bool APIServerConnectionBase::send_text_sensor_state_response(const TextSensorSt
 bool APIServerConnectionBase::send_subscribe_logs_response(const SubscribeLogsResponse &msg) {
   return this->send_message_<SubscribeLogsResponse>(msg, 29);
 }
-#ifdef USE_API_NOISE
-#endif
-#ifdef USE_API_NOISE
-bool APIServerConnectionBase::send_noise_encryption_set_key_response(const NoiseEncryptionSetKeyResponse &msg) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  ESP_LOGVV(TAG, "send_noise_encryption_set_key_response: %s", msg.dump().c_str());
-#endif
-  return this->send_message_<NoiseEncryptionSetKeyResponse>(msg, 125);
-}
-#endif
 bool APIServerConnectionBase::send_homeassistant_service_response(const HomeassistantServiceResponse &msg) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_homeassistant_service_response: %s", msg.dump().c_str());
@@ -1201,17 +1191,6 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_voice_assistant_set_configuration: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_set_configuration(msg);
-#endif
-      break;
-    }
-    case 124: {
-#ifdef USE_API_NOISE
-      NoiseEncryptionSetKeyRequest msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      ESP_LOGVV(TAG, "on_noise_encryption_set_key_request: %s", msg.dump().c_str());
-#endif
-      this->on_noise_encryption_set_key_request(msg);
 #endif
       break;
     }
@@ -1332,22 +1311,6 @@ void APIServerConnection::on_execute_service_request(const ExecuteServiceRequest
   }
   this->execute_service(msg);
 }
-#ifdef USE_API_NOISE
-void APIServerConnection::on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) {
-  if (!this->is_connection_setup()) {
-    this->on_no_setup_connection();
-    return;
-  }
-  if (!this->is_authenticated()) {
-    this->on_unauthenticated_access();
-    return;
-  }
-  NoiseEncryptionSetKeyResponse ret = this->noise_encryption_set_key(msg);
-  if (!this->send_noise_encryption_set_key_response(ret)) {
-    this->on_fatal_error();
-  }
-}
-#endif
 #ifdef USE_COVER
 void APIServerConnection::on_cover_command_request(const CoverCommandRequest &msg) {
   if (!this->is_connection_setup()) {

esphome/components/api/api_pb2_service.h

@@ -83,12 +83,6 @@ class APIServerConnectionBase : public ProtoService {
 #endif
   virtual void on_subscribe_logs_request(const SubscribeLogsRequest &value){};
   bool send_subscribe_logs_response(const SubscribeLogsResponse &msg);
-#ifdef USE_API_NOISE
-  virtual void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &value){};
-#endif
-#ifdef USE_API_NOISE
-  bool send_noise_encryption_set_key_response(const NoiseEncryptionSetKeyResponse &msg);
-#endif
   virtual void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &value){};
   bool send_homeassistant_service_response(const HomeassistantServiceResponse &msg);
   virtual void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &value){};
@@ -355,9 +349,6 @@ class APIServerConnection : public APIServerConnectionBase {
   virtual void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) = 0;
   virtual GetTimeResponse get_time(const GetTimeRequest &msg) = 0;
   virtual void execute_service(const ExecuteServiceRequest &msg) = 0;
-#ifdef USE_API_NOISE
-  virtual NoiseEncryptionSetKeyResponse noise_encryption_set_key(const NoiseEncryptionSetKeyRequest &msg) = 0;
-#endif
 #ifdef USE_COVER
   virtual void cover_command(const CoverCommandRequest &msg) = 0;
 #endif
@@ -466,9 +457,6 @@ class APIServerConnection : public APIServerConnectionBase {
   void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) override;
   void on_get_time_request(const GetTimeRequest &msg) override;
   void on_execute_service_request(const ExecuteServiceRequest &msg) override;
-#ifdef USE_API_NOISE
-  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) override;
-#endif
 #ifdef USE_COVER
   void on_cover_command_request(const CoverCommandRequest &msg) override;
 #endif

esphome/components/api/api_server.cpp

@@ -22,40 +22,22 @@ namespace api {
 static const char *const TAG = "api";
 
 // APIServer
-APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-APIServer::APIServer() { global_api_server = this; }
-
 void APIServer::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Home Assistant API server...");
   this->setup_controller();
-
-#ifdef USE_API_NOISE
-  uint32_t hash = 88491486UL;
-
-  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(hash, true);
-
-  SavedNoisePsk noise_pref_saved{};
-  if (this->noise_pref_.load(&noise_pref_saved)) {
-    ESP_LOGD(TAG, "Loaded saved Noise PSK");
-
-    this->set_noise_psk(noise_pref_saved.psk);
-  }
-#endif
-
-  this->socket_ = socket::socket_ip(SOCK_STREAM, 0);
-  if (this->socket_ == nullptr) {
-    ESP_LOGW(TAG, "Could not create socket");
+  socket_ = socket::socket_ip(SOCK_STREAM, 0);
+  if (socket_ == nullptr) {
+    ESP_LOGW(TAG, "Could not create socket.");
     this->mark_failed();
     return;
   }
   int enable = 1;
-  int err = this->socket_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
+  int err = socket_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
   if (err != 0) {
     ESP_LOGW(TAG, "Socket unable to set reuseaddr: errno %d", err);
     // we can still continue
   }
-  err = this->socket_->setblocking(false);
+  err = socket_->setblocking(false);
   if (err != 0) {
     ESP_LOGW(TAG, "Socket unable to set nonblocking mode: errno %d", err);
     this->mark_failed();
@@ -71,14 +53,14 @@ void APIServer::setup() {
     return;
   }
 
-  err = this->socket_->bind((struct sockaddr *) &server, sl);
+  err = socket_->bind((struct sockaddr *) &server, sl);
   if (err != 0) {
     ESP_LOGW(TAG, "Socket unable to bind: errno %d", errno);
     this->mark_failed();
     return;
   }
 
-  err = this->socket_->listen(4);
+  err = socket_->listen(4);
   if (err != 0) {
     ESP_LOGW(TAG, "Socket unable to listen: errno %d", errno);
     this->mark_failed();
@@ -110,19 +92,18 @@ void APIServer::setup() {
   }
 #endif
 }
-
 void APIServer::loop() {
   // Accept new clients
   while (true) {
     struct sockaddr_storage source_addr;
     socklen_t addr_len = sizeof(source_addr);
-    auto sock = this->socket_->accept((struct sockaddr *) &source_addr, &addr_len);
+    auto sock = socket_->accept((struct sockaddr *) &source_addr, &addr_len);
     if (!sock)
       break;
     ESP_LOGD(TAG, "Accepted %s", sock->getpeername().c_str());
 
     auto *conn = new APIConnection(std::move(sock), this);
-    this->clients_.emplace_back(conn);
+    clients_.emplace_back(conn);
     conn->start();
   }
 
@@ -155,22 +136,16 @@ void APIServer::loop() {
     }
   }
 }
-
 void APIServer::dump_config() {
   ESP_LOGCONFIG(TAG, "API Server:");
   ESP_LOGCONFIG(TAG, "  Address: %s:%u", network::get_use_address().c_str(), this->port_);
 #ifdef USE_API_NOISE
-  ESP_LOGCONFIG(TAG, "  Using noise encryption: %s", YESNO(this->noise_ctx_->has_psk()));
-  if (!this->noise_ctx_->has_psk()) {
-    ESP_LOGCONFIG(TAG, "  Supports noise encryption: YES");
-  }
+  ESP_LOGCONFIG(TAG, "  Using noise encryption: YES");
 #else
   ESP_LOGCONFIG(TAG, "  Using noise encryption: NO");
 #endif
 }
-
 bool APIServer::uses_password() const { return !this->password_.empty(); }
-
 bool APIServer::check_password(const std::string &password) const {
   // depend only on input password length
   const char *a = this->password_.c_str();
@@ -199,9 +174,7 @@ bool APIServer::check_password(const std::string &password) const {
 
   return result == 0;
 }
-
 void APIServer::handle_disconnect(APIConnection *conn) {}
-
 #ifdef USE_BINARY_SENSOR
 void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
   if (obj->is_internal())
@@ -369,27 +342,18 @@ void APIServer::on_update(update::UpdateEntity *obj) {
 }
 #endif
 
-#ifdef USE_ALARM_CONTROL_PANEL
-void APIServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) {
-  if (obj->is_internal())
-    return;
-  for (auto &c : this->clients_)
-    c->send_alarm_control_panel_state(obj);
-}
-#endif
-
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
-
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
+APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void APIServer::set_password(const std::string &password) { this->password_ = password; }
-
 void APIServer::send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
   for (auto &client : this->clients_) {
     client->send_homeassistant_service_call(call);
   }
 }
 
+APIServer::APIServer() { global_api_server = this; }
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
                                                std::function<void(std::string)> f) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
@@ -399,7 +363,6 @@ void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<s
       .once = false,
   });
 }
-
 void APIServer::get_home_assistant_state(std::string entity_id, optional<std::string> attribute,
                                          std::function<void(std::string)> f) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
@@ -409,47 +372,11 @@ void APIServer::get_home_assistant_state(std::string entity_id, optional<std::st
       .once = true,
   });
 };
-
 const std::vector<APIServer::HomeAssistantStateSubscription> &APIServer::get_state_subs() const {
   return this->state_subs_;
 }
-
 uint16_t APIServer::get_port() const { return this->port_; }
-
 void APIServer::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
-
-#ifdef USE_API_NOISE
-bool APIServer::save_noise_psk(psk_t psk, bool make_active) {
-  auto &old_psk = this->noise_ctx_->get_psk();
-  if (std::equal(old_psk.begin(), old_psk.end(), psk.begin())) {
-    ESP_LOGW(TAG, "New PSK matches old");
-    return true;
-  }
-
-  SavedNoisePsk new_saved_psk{psk};
-  if (!this->noise_pref_.save(&new_saved_psk)) {
-    ESP_LOGW(TAG, "Failed to save Noise PSK");
-    return false;
-  }
-  // ensure it's written immediately
-  if (!global_preferences->sync()) {
-    ESP_LOGW(TAG, "Failed to sync preferences");
-    return false;
-  }
-  ESP_LOGD(TAG, "Noise PSK saved");
-  if (make_active) {
-    this->set_timeout(100, [this, psk]() {
-      ESP_LOGW(TAG, "Disconnecting all clients to reset connections");
-      this->set_noise_psk(psk);
-      for (auto &c : this->clients_) {
-        c->send_disconnect_request(DisconnectRequest());
-      }
-    });
-  }
-  return true;
-}
-#endif
-
 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
   for (auto &client : this->clients_) {
@@ -458,9 +385,7 @@ void APIServer::request_time() {
   }
 }
 #endif
-
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
-
 void APIServer::on_shutdown() {
   for (auto &c : this->clients_) {
     c->send_disconnect_request(DisconnectRequest());
@@ -468,6 +393,15 @@ void APIServer::on_shutdown() {
   delay(10);
 }
 
+#ifdef USE_ALARM_CONTROL_PANEL
+void APIServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_alarm_control_panel_state(obj);
+}
+#endif
+
 }  // namespace api
 }  // namespace esphome
 #endif

esphome/components/api/api_server.h

@@ -19,12 +19,6 @@
 namespace esphome {
 namespace api {
 
-#ifdef USE_API_NOISE
-struct SavedNoisePsk {
-  psk_t psk;
-} PACKED;  // NOLINT
-#endif
-
 class APIServer : public Component, public Controller {
  public:
   APIServer();
@@ -41,7 +35,6 @@ class APIServer : public Component, public Controller {
   void set_reboot_timeout(uint32_t reboot_timeout);
 
 #ifdef USE_API_NOISE
-  bool save_noise_psk(psk_t psk, bool make_active = true);
   void set_noise_psk(psk_t psk) { noise_ctx_->set_psk(psk); }
   std::shared_ptr<APINoiseContext> get_noise_ctx() { return noise_ctx_; }
 #endif  // USE_API_NOISE
@@ -149,7 +142,6 @@ class APIServer : public Component, public Controller {
 
 #ifdef USE_API_NOISE
   std::shared_ptr<APINoiseContext> noise_ctx_ = std::make_shared<APINoiseContext>();
-  ESPPreferenceObject noise_pref_;
 #endif  // USE_API_NOISE
 };
 

esphome/components/api/client.py

@@ -29,9 +29,8 @@ async def async_run_logs(config: dict[str, Any], address: str) -> None:
     port: int = int(conf[CONF_PORT])
     password: str = conf[CONF_PASSWORD]
     noise_psk: str | None = None
-    if encryption_config := conf.get(CONF_ENCRYPTION):
-        if key := encryption_config.get(CONF_KEY):
-            noise_psk = key
+    if CONF_ENCRYPTION in conf:
+        noise_psk = conf[CONF_ENCRYPTION][CONF_KEY]
     _LOGGER.info("Starting log output from %s using esphome API", address)
     cli = APIClient(
         address,

esphome/components/as3935_i2c/as3935_i2c.h

@@ -1,10 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/components/as3935/as3935.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/binary_sensor/binary_sensor.h"
 
 namespace esphome {
 namespace as3935_i2c {

esphome/components/color/__init__.py

@@ -3,8 +3,6 @@ from esphome.const import CONF_BLUE, CONF_GREEN, CONF_ID, CONF_RED, CONF_WHITE
 
 ColorStruct = cg.esphome_ns.struct("Color")
 
-INSTANCE_TYPE = ColorStruct
-
 MULTI_CONF = True
 
 CONF_RED_INT = "red_int"

esphome/components/const/__init__.py

@@ -1,5 +0,0 @@
-"""Constants used by esphome components."""
-
-CODEOWNERS = ["@esphome/core"]
-
-CONF_DRAW_ROUNDING = "draw_rounding"

esphome/components/display/rect.cpp

@@ -69,21 +69,16 @@ bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) const {  // NOL
     return true;
   }
   if (absolute) {
-    return ((test_x >= this->x) && (test_x <= this->x2()) && (test_y >= this->y) && (test_y <= this->y2()));
-  } else {
-    return ((test_x >= 0) && (test_x <= this->w) && (test_y >= 0) && (test_y <= this->h));
+    return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
   }
+  return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
 }
 
-bool Rect::inside(Rect rect, bool absolute) const {
+bool Rect::inside(Rect rect) const {
   if (!this->is_set() || !rect.is_set()) {
     return true;
   }
-  if (absolute) {
-    return ((rect.x <= this->x2()) && (rect.x2() >= this->x) && (rect.y <= this->y2()) && (rect.y2() >= this->y));
-  } else {
-    return ((rect.x <= this->w) && (rect.w >= 0) && (rect.y <= this->h) && (rect.h >= 0));
-  }
+  return this->x2() >= rect.x && this->x <= rect.x2() && this->y2() >= rect.y && this->y <= rect.y2();
 }
 
 void Rect::info(const std::string &prefix) {

esphome/components/display/rect.h

@@ -26,7 +26,7 @@ class Rect {
   void extend(Rect rect);
   void shrink(Rect rect);
 
-  bool inside(Rect rect, bool absolute = true) const;
+  bool inside(Rect rect) const;
   bool inside(int16_t test_x, int16_t test_y, bool absolute = true) const;
   bool equal(Rect rect) const;
   void info(const std::string &prefix = "rect info:");

esphome/components/ens160_base/ens160_base.cpp

@@ -187,7 +187,7 @@ void ENS160Component::update() {
       }
       return;
     case INVALID_OUTPUT:
-      ESP_LOGE(TAG, "ENS160 Invalid Status - No Invalid Output");
+      ESP_LOGE(TAG, "ENS160 Invalid Status - No valid output");
       this->status_set_warning();
       return;
   }

esphome/components/esp32/__init__.py

@@ -251,7 +251,7 @@ ARDUINO_PLATFORM_VERSION = cv.Version(5, 4, 0)
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
-RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 1, 6)
+RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 1, 5)
 # The platformio/espressif32 version to use for esp-idf frameworks
 #  - https://github.com/platformio/platform-espressif32/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32
@@ -274,15 +274,12 @@ SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
 # pioarduino versions that don't require a release number
 # List based on https://github.com/pioarduino/esp-idf/releases
 SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
-    cv.Version(5, 5, 0),
     cv.Version(5, 4, 1),
     cv.Version(5, 4, 0),
-    cv.Version(5, 3, 3),
     cv.Version(5, 3, 2),
     cv.Version(5, 3, 1),
     cv.Version(5, 3, 0),
     cv.Version(5, 1, 5),
-    cv.Version(5, 1, 6),
 ]
 
 
@@ -324,8 +321,8 @@ def _arduino_check_versions(value):
 def _esp_idf_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": (cv.Version(5, 1, 6), "https://github.com/espressif/esp-idf.git"),
-        "latest": (cv.Version(5, 1, 6), None),
+        "dev": (cv.Version(5, 1, 5), "https://github.com/espressif/esp-idf.git"),
+        "latest": (cv.Version(5, 1, 5), None),
         "recommended": (RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION, None),
     }
 

esphome/components/esp32_ble/ble.cpp

@@ -2,10 +2,6 @@
 
 #include "ble.h"
 
-#ifdef USE_ESP32_VARIANT_ESP32C6
-#include "const_esp32c6.h"
-#endif  // USE_ESP32_VARIANT_ESP32C6
-
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
 
@@ -127,11 +123,7 @@ bool ESP32BLE::ble_setup_() {
   if (esp_bt_controller_get_status() != ESP_BT_CONTROLLER_STATUS_ENABLED) {
     // start bt controller
     if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
-#ifdef USE_ESP32_VARIANT_ESP32C6
-      esp_bt_controller_config_t cfg = BT_CONTROLLER_CONFIG;
-#else
       esp_bt_controller_config_t cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
-#endif
       err = esp_bt_controller_init(&cfg);
       if (err != ESP_OK) {
         ESP_LOGE(TAG, "esp_bt_controller_init failed: %s", esp_err_to_name(err));

esphome/components/esp32_ble/const_esp32c6.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32_VARIANT_ESP32C6
-
-#include <esp_bt.h>
-
-namespace esphome {
-namespace esp32_ble {
-
-static const esp_bt_controller_config_t BT_CONTROLLER_CONFIG = {
-    .config_version = CONFIG_VERSION,
-    .ble_ll_resolv_list_size = CONFIG_BT_LE_LL_RESOLV_LIST_SIZE,
-    .ble_hci_evt_hi_buf_count = DEFAULT_BT_LE_HCI_EVT_HI_BUF_COUNT,
-    .ble_hci_evt_lo_buf_count = DEFAULT_BT_LE_HCI_EVT_LO_BUF_COUNT,
-    .ble_ll_sync_list_cnt = DEFAULT_BT_LE_MAX_PERIODIC_ADVERTISER_LIST,
-    .ble_ll_sync_cnt = DEFAULT_BT_LE_MAX_PERIODIC_SYNCS,
-    .ble_ll_rsp_dup_list_count = CONFIG_BT_LE_LL_DUP_SCAN_LIST_COUNT,
-    .ble_ll_adv_dup_list_count = CONFIG_BT_LE_LL_DUP_SCAN_LIST_COUNT,
-    .ble_ll_tx_pwr_dbm = BLE_LL_TX_PWR_DBM_N,
-    .rtc_freq = RTC_FREQ_N,
-    .ble_ll_sca = CONFIG_BT_LE_LL_SCA,
-    .ble_ll_scan_phy_number = BLE_LL_SCAN_PHY_NUMBER_N,
-    .ble_ll_conn_def_auth_pyld_tmo = BLE_LL_CONN_DEF_AUTH_PYLD_TMO_N,
-    .ble_ll_jitter_usecs = BLE_LL_JITTER_USECS_N,
-    .ble_ll_sched_max_adv_pdu_usecs = BLE_LL_SCHED_MAX_ADV_PDU_USECS_N,
-    .ble_ll_sched_direct_adv_max_usecs = BLE_LL_SCHED_DIRECT_ADV_MAX_USECS_N,
-    .ble_ll_sched_adv_max_usecs = BLE_LL_SCHED_ADV_MAX_USECS_N,
-    .ble_scan_rsp_data_max_len = DEFAULT_BT_LE_SCAN_RSP_DATA_MAX_LEN_N,
-    .ble_ll_cfg_num_hci_cmd_pkts = BLE_LL_CFG_NUM_HCI_CMD_PKTS_N,
-    .ble_ll_ctrl_proc_timeout_ms = BLE_LL_CTRL_PROC_TIMEOUT_MS_N,
-    .nimble_max_connections = DEFAULT_BT_LE_MAX_CONNECTIONS,
-    .ble_whitelist_size = DEFAULT_BT_NIMBLE_WHITELIST_SIZE,  // NOLINT
-    .ble_acl_buf_size = DEFAULT_BT_LE_ACL_BUF_SIZE,
-    .ble_acl_buf_count = DEFAULT_BT_LE_ACL_BUF_COUNT,
-    .ble_hci_evt_buf_size = DEFAULT_BT_LE_HCI_EVT_BUF_SIZE,
-    .ble_multi_adv_instances = DEFAULT_BT_LE_MAX_EXT_ADV_INSTANCES,
-    .ble_ext_adv_max_size = DEFAULT_BT_LE_EXT_ADV_MAX_SIZE,
-    .controller_task_stack_size = NIMBLE_LL_STACK_SIZE,
-    .controller_task_prio = ESP_TASK_BT_CONTROLLER_PRIO,
-    .controller_run_cpu = 0,
-    .enable_qa_test = RUN_QA_TEST,
-    .enable_bqb_test = RUN_BQB_TEST,
-#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 3, 1)
-    // The following fields have been removed since ESP IDF version 5.3.1, see commit:
-    // https://github.com/espressif/esp-idf/commit/e761c1de8f9c0777829d597b4d5a33bb070a30a8
-    .enable_uart_hci = HCI_UART_EN,
-    .ble_hci_uart_port = DEFAULT_BT_LE_HCI_UART_PORT,
-    .ble_hci_uart_baud = DEFAULT_BT_LE_HCI_UART_BAUD,
-    .ble_hci_uart_data_bits = DEFAULT_BT_LE_HCI_UART_DATA_BITS,
-    .ble_hci_uart_stop_bits = DEFAULT_BT_LE_HCI_UART_STOP_BITS,
-    .ble_hci_uart_flow_ctrl = DEFAULT_BT_LE_HCI_UART_FLOW_CTRL,
-    .ble_hci_uart_uart_parity = DEFAULT_BT_LE_HCI_UART_PARITY,
-#endif
-    .enable_tx_cca = DEFAULT_BT_LE_TX_CCA_ENABLED,
-    .cca_rssi_thresh = 256 - DEFAULT_BT_LE_CCA_RSSI_THRESH,
-    .sleep_en = NIMBLE_SLEEP_ENABLE,
-    .coex_phy_coded_tx_rx_time_limit = DEFAULT_BT_LE_COEX_PHY_CODED_TX_RX_TLIM_EFF,
-    .dis_scan_backoff = NIMBLE_DISABLE_SCAN_BACKOFF,
-    .ble_scan_classify_filter_enable = 1,
-    .main_xtal_freq = CONFIG_XTAL_FREQ,
-    .version_num = (uint8_t) efuse_hal_chip_revision(),
-    .cpu_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ,
-    .ignore_wl_for_direct_adv = 0,
-    .enable_pcl = DEFAULT_BT_LE_POWER_CONTROL_ENABLED,
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 3)
-    .csa2_select = DEFAULT_BT_LE_50_FEATURE_SUPPORT,
-#endif
-    .config_magic = CONFIG_MAGIC,
-};
-
-}  // namespace esp32_ble
-}  // namespace esphome
-
-#endif  // USE_ESP32_VARIANT_ESP32C6

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -57,6 +57,7 @@ void ESP32BLETracker::setup() {
 
   global_esp32_ble_tracker = this;
   this->scan_result_lock_ = xSemaphoreCreateMutex();
+  this->scan_end_lock_ = xSemaphoreCreateMutex();
 
 #ifdef USE_OTA
   ota::get_global_ota_callback()->add_on_state_callback(
@@ -116,104 +117,119 @@ void ESP32BLETracker::loop() {
   }
   bool promote_to_connecting = discovered && !searching && !connecting;
 
-  if (this->scanner_state_ == ScannerState::RUNNING &&
-      this->scan_result_index_ &&  // if it looks like we have a scan result we will take the lock
-      xSemaphoreTake(this->scan_result_lock_, 5L / portTICK_PERIOD_MS)) {
-    uint32_t index = this->scan_result_index_;
-    if (index >= ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
-      ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
-    }
-
-    if (this->raw_advertisements_) {
-      for (auto *listener : this->listeners_) {
-        listener->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
+  if (!this->scanner_idle_) {
+    if (this->scan_result_index_ &&  // if it looks like we have a scan result we will take the lock
+        xSemaphoreTake(this->scan_result_lock_, 5L / portTICK_PERIOD_MS)) {
+      uint32_t index = this->scan_result_index_;
+      if (index >= ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
+        ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
       }
-      for (auto *client : this->clients_) {
-        client->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
-      }
-    }
 
-    if (this->parse_advertisements_) {
-      for (size_t i = 0; i < index; i++) {
-        ESPBTDevice device;
-        device.parse_scan_rst(this->scan_result_buffer_[i]);
-
-        bool found = false;
+      if (this->raw_advertisements_) {
         for (auto *listener : this->listeners_) {
-          if (listener->parse_device(device))
-            found = true;
+          listener->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
         }
-
         for (auto *client : this->clients_) {
-          if (client->parse_device(device)) {
-            found = true;
-            if (!connecting && client->state() == ClientState::DISCOVERED) {
-              promote_to_connecting = true;
+          client->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
+        }
+      }
+
+      if (this->parse_advertisements_) {
+        for (size_t i = 0; i < index; i++) {
+          ESPBTDevice device;
+          device.parse_scan_rst(this->scan_result_buffer_[i]);
+
+          bool found = false;
+          for (auto *listener : this->listeners_) {
+            if (listener->parse_device(device))
+              found = true;
+          }
+
+          for (auto *client : this->clients_) {
+            if (client->parse_device(device)) {
+              found = true;
+              if (!connecting && client->state() == ClientState::DISCOVERED) {
+                promote_to_connecting = true;
+              }
             }
           }
-        }
 
-        if (!found && !this->scan_continuous_) {
-          this->print_bt_device_info(device);
+          if (!found && !this->scan_continuous_) {
+            this->print_bt_device_info(device);
+          }
         }
       }
+      this->scan_result_index_ = 0;
+      xSemaphoreGive(this->scan_result_lock_);
     }
-    this->scan_result_index_ = 0;
-    xSemaphoreGive(this->scan_result_lock_);
-  }
-  if (this->scanner_state_ == ScannerState::STOPPED) {
-    this->end_of_scan_();  // Change state to IDLE
-  }
-  if (this->scanner_state_ == ScannerState::FAILED ||
-      (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
-    this->stop_scan_();
-    if (this->scan_start_fail_count_ == std::numeric_limits<uint8_t>::max()) {
-      ESP_LOGE(TAG, "ESP-IDF BLE scan could not restart after %d attempts, rebooting to restore BLE stack...",
-               std::numeric_limits<uint8_t>::max());
-      App.reboot();
+
+    /*
+
+      Avoid starting the scanner if:
+      - we are already scanning
+      - we are connecting to a device
+      - we are disconnecting from a device
+
+      Otherwise the scanner could fail to ever start again
+      and our only way to recover is to reboot.
+
+      https://github.com/espressif/esp-idf/issues/6688
+
+    */
+    if (!connecting && xSemaphoreTake(this->scan_end_lock_, 0L)) {
+      if (this->scan_continuous_) {
+        if (!disconnecting && !promote_to_connecting && !this->scan_start_failed_ && !this->scan_set_param_failed_) {
+          this->start_scan_(false);
+        } else {
+          // We didn't start the scan, so we need to release the lock
+          xSemaphoreGive(this->scan_end_lock_);
+        }
+      } else if (!this->scanner_idle_) {
+        this->end_of_scan_();
+        return;
+      }
     }
-    if (this->scan_start_failed_) {
-      ESP_LOGE(TAG, "Scan start failed: %d", this->scan_start_failed_);
-      this->scan_start_failed_ = ESP_BT_STATUS_SUCCESS;
-    }
-    if (this->scan_set_param_failed_) {
-      ESP_LOGE(TAG, "Scan set param failed: %d", this->scan_set_param_failed_);
-      this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
+
+    if (this->scan_start_failed_ || this->scan_set_param_failed_) {
+      if (this->scan_start_fail_count_ == std::numeric_limits<uint8_t>::max()) {
+        ESP_LOGE(TAG, "ESP-IDF BLE scan could not restart after %d attempts, rebooting to restore BLE stack...",
+                 std::numeric_limits<uint8_t>::max());
+        App.reboot();
+      }
+      if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
+        xSemaphoreGive(this->scan_end_lock_);
+      } else {
+        ESP_LOGD(TAG, "Stopping scan after failure...");
+        this->stop_scan_();
+      }
+      if (this->scan_start_failed_) {
+        ESP_LOGE(TAG, "Scan start failed: %d", this->scan_start_failed_);
+        this->scan_start_failed_ = ESP_BT_STATUS_SUCCESS;
+      }
+      if (this->scan_set_param_failed_) {
+        ESP_LOGE(TAG, "Scan set param failed: %d", this->scan_set_param_failed_);
+        this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
+      }
     }
   }
-  /*
 
-    Avoid starting the scanner if:
-    - we are already scanning
-    - we are connecting to a device
-    - we are disconnecting from a device
-
-    Otherwise the scanner could fail to ever start again
-    and our only way to recover is to reboot.
-
-    https://github.com/espressif/esp-idf/issues/6688
-
-  */
-  if (this->scanner_state_ == ScannerState::IDLE && this->scan_continuous_ && !connecting && !disconnecting &&
-      !promote_to_connecting) {
-    this->start_scan_(false);  // first = false
-  }
   // If there is a discovered client and no connecting
   // clients and no clients using the scanner to search for
   // devices, then stop scanning and promote the discovered
   // client to ready to connect.
-  if (promote_to_connecting &&
-      (this->scanner_state_ == ScannerState::RUNNING || this->scanner_state_ == ScannerState::IDLE)) {
+  if (promote_to_connecting) {
     for (auto *client : this->clients_) {
       if (client->state() == ClientState::DISCOVERED) {
-        if (this->scanner_state_ == ScannerState::RUNNING) {
-          ESP_LOGD(TAG, "Stopping scan to make connection...");
-          this->stop_scan_();
-        } else if (this->scanner_state_ == ScannerState::IDLE) {
-          ESP_LOGD(TAG, "Promoting client to connect...");
+        if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
+          // Scanner is not running since we got the
+          // lock, so we can promote the client.
+          xSemaphoreGive(this->scan_end_lock_);
           // We only want to promote one client at a time.
           // once the scanner is fully stopped.
           client->set_state(ClientState::READY_TO_CONNECT);
+        } else {
+          ESP_LOGD(TAG, "Pausing scan to make connection...");
+          this->stop_scan_();
         }
         break;
       }
@@ -221,7 +237,13 @@ void ESP32BLETracker::loop() {
   }
 }
 
-void ESP32BLETracker::start_scan() { this->start_scan_(true); }
+void ESP32BLETracker::start_scan() {
+  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
+    this->start_scan_(true);
+  } else {
+    ESP_LOGW(TAG, "Scan requested when a scan is already in progress. Ignoring.");
+  }
+}
 
 void ESP32BLETracker::stop_scan() {
   ESP_LOGD(TAG, "Stopping scan.");
@@ -229,23 +251,16 @@ void ESP32BLETracker::stop_scan() {
   this->stop_scan_();
 }
 
-void ESP32BLETracker::ble_before_disabled_event_handler() { this->stop_scan_(); }
+void ESP32BLETracker::ble_before_disabled_event_handler() {
+  this->stop_scan_();
+  xSemaphoreGive(this->scan_end_lock_);
+}
 
 void ESP32BLETracker::stop_scan_() {
-  if (this->scanner_state_ != ScannerState::RUNNING && this->scanner_state_ != ScannerState::FAILED) {
-    if (this->scanner_state_ == ScannerState::IDLE) {
-      ESP_LOGE(TAG, "Scan is already stopped while trying to stop.");
-    } else if (this->scanner_state_ == ScannerState::STARTING) {
-      ESP_LOGE(TAG, "Scan is starting while trying to stop.");
-    } else if (this->scanner_state_ == ScannerState::STOPPING) {
-      ESP_LOGE(TAG, "Scan is already stopping while trying to stop.");
-    } else if (this->scanner_state_ == ScannerState::STOPPED) {
-      ESP_LOGE(TAG, "Scan is already stopped while trying to stop.");
-    }
+  this->cancel_timeout("scan");
+  if (this->scanner_idle_) {
     return;
   }
-  this->cancel_timeout("scan");
-  this->scanner_state_ = ScannerState::STOPPING;
   esp_err_t err = esp_ble_gap_stop_scanning();
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "esp_ble_gap_stop_scanning failed: %d", err);
@@ -258,22 +273,13 @@ void ESP32BLETracker::start_scan_(bool first) {
     ESP_LOGW(TAG, "Cannot start scan while ESP32BLE is disabled.");
     return;
   }
-  if (this->scanner_state_ != ScannerState::IDLE) {
-    if (this->scanner_state_ == ScannerState::STARTING) {
-      ESP_LOGE(TAG, "Cannot start scan while already starting.");
-    } else if (this->scanner_state_ == ScannerState::RUNNING) {
-      ESP_LOGE(TAG, "Cannot start scan while already running.");
-    } else if (this->scanner_state_ == ScannerState::STOPPING) {
-      ESP_LOGE(TAG, "Cannot start scan while already stopping.");
-    } else if (this->scanner_state_ == ScannerState::FAILED) {
-      ESP_LOGE(TAG, "Cannot start scan while already failed.");
-    } else if (this->scanner_state_ == ScannerState::STOPPED) {
-      ESP_LOGE(TAG, "Cannot start scan while already stopped.");
-    }
+  // The lock must be held when calling this function.
+  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
+    ESP_LOGE(TAG, "start_scan called without holding scan_end_lock_");
     return;
   }
-  this->scanner_state_ = ScannerState::STARTING;
-  ESP_LOGD(TAG, "Starting scan, set scanner state to STARTING.");
+
+  ESP_LOGD(TAG, "Starting scan...");
   if (!first) {
     for (auto *listener : this->listeners_)
       listener->on_scan_end();
@@ -301,21 +307,24 @@ void ESP32BLETracker::start_scan_(bool first) {
     ESP_LOGE(TAG, "esp_ble_gap_start_scanning failed: %d", err);
     return;
   }
+  this->scanner_idle_ = false;
 }
 
 void ESP32BLETracker::end_of_scan_() {
   // The lock must be held when calling this function.
-  if (this->scanner_state_ != ScannerState::STOPPED) {
-    ESP_LOGE(TAG, "end_of_scan_ called while scanner is not stopped.");
+  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
+    ESP_LOGE(TAG, "end_of_scan_ called without holding the scan_end_lock_");
     return;
   }
-  ESP_LOGD(TAG, "End of scan, set scanner state to IDLE.");
+
+  ESP_LOGD(TAG, "End of scan.");
+  this->scanner_idle_ = true;
   this->already_discovered_.clear();
+  xSemaphoreGive(this->scan_end_lock_);
   this->cancel_timeout("scan");
 
   for (auto *listener : this->listeners_)
     listener->on_scan_end();
-  this->scanner_state_ = ScannerState::IDLE;
 }
 
 void ESP32BLETracker::register_client(ESPBTClient *client) {
@@ -383,46 +392,19 @@ void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t:
 void ESP32BLETracker::gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) {
   ESP_LOGV(TAG, "gap_scan_start_complete - status %d", param.status);
   this->scan_start_failed_ = param.status;
-  if (this->scanner_state_ != ScannerState::STARTING) {
-    if (this->scanner_state_ == ScannerState::RUNNING) {
-      ESP_LOGE(TAG, "Scan was already running when start complete.");
-    } else if (this->scanner_state_ == ScannerState::STOPPING) {
-      ESP_LOGE(TAG, "Scan was stopping when start complete.");
-    } else if (this->scanner_state_ == ScannerState::FAILED) {
-      ESP_LOGE(TAG, "Scan was in failed state when start complete.");
-    } else if (this->scanner_state_ == ScannerState::IDLE) {
-      ESP_LOGE(TAG, "Scan was idle when start complete.");
-    } else if (this->scanner_state_ == ScannerState::STOPPED) {
-      ESP_LOGE(TAG, "Scan was stopped when start complete.");
-    }
-  }
   if (param.status == ESP_BT_STATUS_SUCCESS) {
     this->scan_start_fail_count_ = 0;
-    this->scanner_state_ = ScannerState::RUNNING;
   } else {
-    this->scanner_state_ = ScannerState::FAILED;
     if (this->scan_start_fail_count_ != std::numeric_limits<uint8_t>::max()) {
       this->scan_start_fail_count_++;
     }
+    xSemaphoreGive(this->scan_end_lock_);
   }
 }
 
 void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param) {
   ESP_LOGV(TAG, "gap_scan_stop_complete - status %d", param.status);
-  if (this->scanner_state_ != ScannerState::STOPPING) {
-    if (this->scanner_state_ == ScannerState::RUNNING) {
-      ESP_LOGE(TAG, "Scan was not running when stop complete.");
-    } else if (this->scanner_state_ == ScannerState::STARTING) {
-      ESP_LOGE(TAG, "Scan was not started when stop complete.");
-    } else if (this->scanner_state_ == ScannerState::FAILED) {
-      ESP_LOGE(TAG, "Scan was in failed state when stop complete.");
-    } else if (this->scanner_state_ == ScannerState::IDLE) {
-      ESP_LOGE(TAG, "Scan was idle when stop complete.");
-    } else if (this->scanner_state_ == ScannerState::STOPPED) {
-      ESP_LOGE(TAG, "Scan was stopped when stop complete.");
-    }
-  }
-  this->scanner_state_ = ScannerState::STOPPED;
+  xSemaphoreGive(this->scan_end_lock_);
 }
 
 void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
@@ -435,21 +417,7 @@ void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_re
       xSemaphoreGive(this->scan_result_lock_);
     }
   } else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
-    // Scan finished on its own
-    if (this->scanner_state_ != ScannerState::RUNNING) {
-      if (this->scanner_state_ == ScannerState::STOPPING) {
-        ESP_LOGE(TAG, "Scan was not running when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STARTING) {
-        ESP_LOGE(TAG, "Scan was not started when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::FAILED) {
-        ESP_LOGE(TAG, "Scan was in failed state when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::IDLE) {
-        ESP_LOGE(TAG, "Scan was idle when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STOPPED) {
-        ESP_LOGE(TAG, "Scan was stopped when scan completed.");
-      }
-    }
-    this->scanner_state_ = ScannerState::STOPPED;
+    xSemaphoreGive(this->scan_end_lock_);
   }
 }
 
@@ -712,26 +680,8 @@ void ESP32BLETracker::dump_config() {
   ESP_LOGCONFIG(TAG, "  Scan Window: %.1f ms", this->scan_window_ * 0.625f);
   ESP_LOGCONFIG(TAG, "  Scan Type: %s", this->scan_active_ ? "ACTIVE" : "PASSIVE");
   ESP_LOGCONFIG(TAG, "  Continuous Scanning: %s", YESNO(this->scan_continuous_));
-  switch (this->scanner_state_) {
-    case ScannerState::IDLE:
-      ESP_LOGCONFIG(TAG, "  Scanner State: IDLE");
-      break;
-    case ScannerState::STARTING:
-      ESP_LOGCONFIG(TAG, "  Scanner State: STARTING");
-      break;
-    case ScannerState::RUNNING:
-      ESP_LOGCONFIG(TAG, "  Scanner State: RUNNING");
-      break;
-    case ScannerState::STOPPING:
-      ESP_LOGCONFIG(TAG, "  Scanner State: STOPPING");
-      break;
-    case ScannerState::STOPPED:
-      ESP_LOGCONFIG(TAG, "  Scanner State: STOPPED");
-      break;
-    case ScannerState::FAILED:
-      ESP_LOGCONFIG(TAG, "  Scanner State: FAILED");
-      break;
-  }
+  ESP_LOGCONFIG(TAG, "  Scanner Idle: %s", YESNO(this->scanner_idle_));
+  ESP_LOGCONFIG(TAG, "  Scan End: %s", YESNO(xSemaphoreGetMutexHolder(this->scan_end_lock_) == nullptr));
   ESP_LOGCONFIG(TAG, "  Connecting: %d, discovered: %d, searching: %d, disconnecting: %d", connecting_, discovered_,
                 searching_, disconnecting_);
   if (this->scan_start_fail_count_) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -154,21 +154,6 @@ enum class ClientState {
   ESTABLISHED,
 };
 
-enum class ScannerState {
-  // Scanner is idle, init state, set from the main loop when processing STOPPED
-  IDLE,
-  // Scanner is starting, set from the main loop only
-  STARTING,
-  // Scanner is running, set from the ESP callback only
-  RUNNING,
-  // Scanner failed to start, set from the ESP callback only
-  FAILED,
-  // Scanner is stopping, set from the main loop only
-  STOPPING,
-  // Scanner is stopped, set from the ESP callback only
-  STOPPED,
-};
-
 enum class ConnectionType {
   // The default connection type, we hold all the services in ram
   // for the duration of the connection.
@@ -272,11 +257,12 @@ class ESP32BLETracker : public Component,
   uint8_t scan_start_fail_count_{0};
   bool scan_continuous_;
   bool scan_active_;
-  ScannerState scanner_state_{ScannerState::IDLE};
+  bool scanner_idle_{true};
   bool ble_was_disabled_{true};
   bool raw_advertisements_{false};
   bool parse_advertisements_{false};
   SemaphoreHandle_t scan_result_lock_;
+  SemaphoreHandle_t scan_end_lock_;
   size_t scan_result_index_{0};
 #ifdef USE_PSRAM
   const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 32;

esphome/components/esp32_can/esp32_can.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "esp32_can";
 static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config) {
   switch (bitrate) {
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32C3) || \
-    defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H2)
+    defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32H6)
     case canbus::CAN_1KBPS:
       *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_1KBITS();
       return true;

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -58,7 +58,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
   channel.flags.io_loop_back = 0;
   channel.flags.io_od_mode = 0;
   channel.flags.invert_out = 0;
-  channel.flags.with_dma = this->use_dma_;
+  channel.flags.with_dma = 0;
   channel.intr_priority = 0;
   if (rmt_new_tx_channel(&channel, &this->channel_) != ESP_OK) {
     ESP_LOGE(TAG, "Channel creation failed");

esphome/components/esp32_rmt_led_strip/led_strip.h

@@ -51,7 +51,6 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
   void set_num_leds(uint16_t num_leds) { this->num_leds_ = num_leds; }
   void set_is_rgbw(bool is_rgbw) { this->is_rgbw_ = is_rgbw; }
   void set_is_wrgb(bool is_wrgb) { this->is_wrgb_ = is_wrgb; }
-  void set_use_dma(bool use_dma) { this->use_dma_ = use_dma; }
   void set_use_psram(bool use_psram) { this->use_psram_ = use_psram; }
 
   /// Set a maximum refresh rate in µs as some lights do not like being updated too often.
@@ -86,7 +85,7 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
   rmt_encoder_handle_t encoder_{nullptr};
   rmt_symbol_word_t *rmt_buf_{nullptr};
   rmt_symbol_word_t bit0_, bit1_, reset_;
-  uint32_t rmt_symbols_{48};
+  uint32_t rmt_symbols_;
 #else
   rmt_item32_t *rmt_buf_{nullptr};
   rmt_item32_t bit0_, bit1_, reset_;
@@ -95,12 +94,11 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
 
   uint8_t pin_;
   uint16_t num_leds_;
-  bool is_rgbw_{false};
-  bool is_wrgb_{false};
-  bool use_dma_{false};
-  bool use_psram_{false};
+  bool is_rgbw_;
+  bool is_wrgb_;
+  bool use_psram_;
 
-  RGBOrder rgb_order_{ORDER_RGB};
+  RGBOrder rgb_order_;
 
   uint32_t last_refresh_{0};
   optional<uint32_t> max_refresh_rate_{};

esphome/components/esp32_rmt_led_strip/light.py

@@ -3,7 +3,7 @@ import logging
 
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32, esp32_rmt, light
+from esphome.components import esp32_rmt, light
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHIPSET,
@@ -15,7 +15,6 @@ from esphome.const import (
     CONF_RGB_ORDER,
     CONF_RMT_CHANNEL,
     CONF_RMT_SYMBOLS,
-    CONF_USE_DMA,
 )
 from esphome.core import CORE
 
@@ -139,11 +138,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
             cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
             cv.Optional(CONF_IS_WRGB, default=False): cv.boolean,
-            cv.Optional(CONF_USE_DMA): cv.All(
-                esp32.only_on_variant(supported=[esp32.const.VARIANT_ESP32S3]),
-                cv.only_with_esp_idf,
-                cv.boolean,
-            ),
             cv.Optional(CONF_USE_PSRAM, default=True): cv.boolean,
             cv.Inclusive(
                 CONF_BIT0_HIGH,
@@ -217,8 +211,6 @@ async def to_code(config):
 
     if esp32_rmt.use_new_rmt_driver():
         cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
-        if CONF_USE_DMA in config:
-            cg.add(var.set_use_dma(config[CONF_USE_DMA]))
     else:
         rmt_channel_t = cg.global_ns.enum("rmt_channel_t")
         cg.add(

esphome/components/hlw8012/hlw8012.cpp

@@ -69,7 +69,7 @@ void HLW8012Component::update() {
 
   float power = cf_hz * this->power_multiplier_;
 
-  if (this->change_mode_at_ != 0) {
+  if (this->change_mode_at_ != 0 || this->change_mode_every_ == 0) {
     // Only read cf1 after one cycle. Apparently it's quite unstable after being changed.
     if (this->current_mode_) {
       float current = cf1_hz * this->current_multiplier_;

esphome/components/http_request/__init__.py

@@ -10,11 +10,9 @@ from esphome.const import (
     CONF_TIMEOUT,
     CONF_TRIGGER_ID,
     CONF_URL,
-    PLATFORM_HOST,
     __version__,
 )
 from esphome.core import CORE, Lambda
-from esphome.helpers import IS_MACOS
 
 DEPENDENCIES = ["network"]
 AUTO_LOAD = ["json", "watchdog"]
@@ -23,7 +21,6 @@ http_request_ns = cg.esphome_ns.namespace("http_request")
 HttpRequestComponent = http_request_ns.class_("HttpRequestComponent", cg.Component)
 HttpRequestArduino = http_request_ns.class_("HttpRequestArduino", HttpRequestComponent)
 HttpRequestIDF = http_request_ns.class_("HttpRequestIDF", HttpRequestComponent)
-HttpRequestHost = http_request_ns.class_("HttpRequestHost", HttpRequestComponent)
 
 HttpContainer = http_request_ns.class_("HttpContainer")
 
@@ -46,13 +43,10 @@ CONF_REDIRECT_LIMIT = "redirect_limit"
 CONF_WATCHDOG_TIMEOUT = "watchdog_timeout"
 CONF_BUFFER_SIZE_RX = "buffer_size_rx"
 CONF_BUFFER_SIZE_TX = "buffer_size_tx"
-CONF_CA_CERTIFICATE_PATH = "ca_certificate_path"
 
 CONF_MAX_RESPONSE_BUFFER_SIZE = "max_response_buffer_size"
 CONF_ON_RESPONSE = "on_response"
 CONF_HEADERS = "headers"
-CONF_REQUEST_HEADERS = "request_headers"
-CONF_COLLECT_HEADERS = "collect_headers"
 CONF_BODY = "body"
 CONF_JSON = "json"
 CONF_CAPTURE_RESPONSE = "capture_response"
@@ -91,8 +85,6 @@ def validate_ssl_verification(config):
 
 
 def _declare_request_class(value):
-    if CORE.is_host:
-        return cv.declare_id(HttpRequestHost)(value)
     if CORE.using_esp_idf:
         return cv.declare_id(HttpRequestIDF)(value)
     if CORE.is_esp8266 or CORE.is_esp32 or CORE.is_rp2040:
@@ -127,10 +119,6 @@ CONFIG_SCHEMA = cv.All(
             cv.SplitDefault(CONF_BUFFER_SIZE_TX, esp32_idf=512): cv.All(
                 cv.uint16_t, cv.only_with_esp_idf
             ),
-            cv.Optional(CONF_CA_CERTIFICATE_PATH): cv.All(
-                cv.file_,
-                cv.only_on(PLATFORM_HOST),
-            ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.require_framework_version(
@@ -138,7 +126,6 @@ CONFIG_SCHEMA = cv.All(
         esp32_arduino=cv.Version(0, 0, 0),
         esp_idf=cv.Version(0, 0, 0),
         rp2040_arduino=cv.Version(0, 0, 0),
-        host=cv.Version(0, 0, 0),
     ),
     validate_ssl_verification,
 )
@@ -181,21 +168,6 @@ async def to_code(config):
         cg.add_library("ESP8266HTTPClient", None)
     if CORE.is_rp2040 and CORE.using_arduino:
         cg.add_library("HTTPClient", None)
-    if CORE.is_host:
-        if IS_MACOS:
-            cg.add_build_flag("-I/opt/homebrew/opt/openssl/include")
-            cg.add_build_flag("-L/opt/homebrew/opt/openssl/lib")
-            cg.add_build_flag("-lssl")
-            cg.add_build_flag("-lcrypto")
-            cg.add_build_flag("-Wl,-framework,CoreFoundation")
-            cg.add_build_flag("-Wl,-framework,Security")
-            cg.add_define("CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN")
-            cg.add_define("CPPHTTPLIB_OPENSSL_SUPPORT")
-        elif path := config.get(CONF_CA_CERTIFICATE_PATH):
-            cg.add_define("CPPHTTPLIB_OPENSSL_SUPPORT")
-            cg.add(var.set_ca_path(path))
-            cg.add_build_flag("-lssl")
-            cg.add_build_flag("-lcrypto")
 
     await cg.register_component(var, config)
 
@@ -204,13 +176,9 @@ HTTP_REQUEST_ACTION_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.use_id(HttpRequestComponent),
         cv.Required(CONF_URL): cv.templatable(validate_url),
-        cv.Optional(CONF_HEADERS): cv.invalid(
-            "The 'headers' options has been renamed to 'request_headers'"
-        ),
-        cv.Optional(CONF_REQUEST_HEADERS): cv.All(
+        cv.Optional(CONF_HEADERS): cv.All(
             cv.Schema({cv.string: cv.templatable(cv.string)})
         ),
-        cv.Optional(CONF_COLLECT_HEADERS): cv.ensure_list(cv.string),
         cv.Optional(CONF_VERIFY_SSL): cv.invalid(
             f"{CONF_VERIFY_SSL} has moved to the base component configuration."
         ),
@@ -295,12 +263,11 @@ async def http_request_action_to_code(config, action_id, template_arg, args):
             for key in json_:
                 template_ = await cg.templatable(json_[key], args, cg.std_string)
                 cg.add(var.add_json(key, template_))
-    for key in config.get(CONF_REQUEST_HEADERS, []):
-        template_ = await cg.templatable(key, args, cg.std_string)
-        cg.add(var.add_request_header(key, template_))
-
-    for value in config.get(CONF_COLLECT_HEADERS, []):
-        cg.add(var.add_collect_header(value))
+    for key in config.get(CONF_HEADERS, []):
+        template_ = await cg.templatable(
+            config[CONF_HEADERS][key], args, cg.const_char_ptr
+        )
+        cg.add(var.add_header(key, template_))
 
     for conf in config.get(CONF_ON_RESPONSE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])

esphome/components/http_request/http_request.cpp

@@ -20,25 +20,5 @@ void HttpRequestComponent::dump_config() {
   }
 }
 
-std::string HttpContainer::get_response_header(const std::string &header_name) {
-  auto response_headers = this->get_response_headers();
-  auto header_name_lower_case = str_lower_case(header_name);
-  if (response_headers.count(header_name_lower_case) == 0) {
-    ESP_LOGW(TAG, "No header with name %s found", header_name_lower_case.c_str());
-    return "";
-  } else {
-    auto values = response_headers[header_name_lower_case];
-    if (values.empty()) {
-      ESP_LOGE(TAG, "header with name %s returned an empty list, this shouldn't happen",
-               header_name_lower_case.c_str());
-      return "";
-    } else {
-      auto header_value = values.front();
-      ESP_LOGD(TAG, "Header with name %s found with value %s", header_name_lower_case.c_str(), header_value.c_str());
-      return header_value;
-    }
-  }
-}
-
 }  // namespace http_request
 }  // namespace esphome

esphome/components/http_request/http_request.h

@@ -3,7 +3,6 @@
 #include <list>
 #include <map>
 #include <memory>
-#include <set>
 #include <utility>
 #include <vector>
 
@@ -96,19 +95,9 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
-  /**
-   * @brief Get response headers.
-   *
-   * @return The key is the lower case response header name, the value is the header value.
-   */
-  std::map<std::string, std::list<std::string>> get_response_headers() { return this->response_headers_; }
-
-  std::string get_response_header(const std::string &header_name);
-
  protected:
   size_t bytes_read_{0};
   bool secure_{false};
-  std::map<std::string, std::list<std::string>> response_headers_{};
 };
 
 class HttpRequestResponseTrigger : public Trigger<std::shared_ptr<HttpContainer>, std::string &> {
@@ -130,46 +119,21 @@ class HttpRequestComponent : public Component {
   void set_follow_redirects(bool follow_redirects) { this->follow_redirects_ = follow_redirects; }
   void set_redirect_limit(uint16_t limit) { this->redirect_limit_ = limit; }
 
-  std::shared_ptr<HttpContainer> get(const std::string &url) { return this->start(url, "GET", "", {}); }
-  std::shared_ptr<HttpContainer> get(const std::string &url, const std::list<Header> &request_headers) {
-    return this->start(url, "GET", "", request_headers);
+  std::shared_ptr<HttpContainer> get(std::string url) { return this->start(std::move(url), "GET", "", {}); }
+  std::shared_ptr<HttpContainer> get(std::string url, std::list<Header> headers) {
+    return this->start(std::move(url), "GET", "", std::move(headers));
   }
-  std::shared_ptr<HttpContainer> get(const std::string &url, const std::list<Header> &request_headers,
-                                     const std::set<std::string> &collect_headers) {
-    return this->start(url, "GET", "", request_headers, collect_headers);
+  std::shared_ptr<HttpContainer> post(std::string url, std::string body) {
+    return this->start(std::move(url), "POST", std::move(body), {});
   }
-  std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body) {
-    return this->start(url, "POST", body, {});
-  }
-  std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
-                                      const std::list<Header> &request_headers) {
-    return this->start(url, "POST", body, request_headers);
-  }
-  std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
-                                      const std::list<Header> &request_headers,
-                                      const std::set<std::string> &collect_headers) {
-    return this->start(url, "POST", body, request_headers, collect_headers);
+  std::shared_ptr<HttpContainer> post(std::string url, std::string body, std::list<Header> headers) {
+    return this->start(std::move(url), "POST", std::move(body), std::move(headers));
   }
 
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
-                                       const std::list<Header> &request_headers) {
-    return this->start(url, method, body, request_headers, {});
-  }
-
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
-                                       const std::list<Header> &request_headers,
-                                       const std::set<std::string> &collect_headers) {
-    std::set<std::string> lower_case_collect_headers;
-    for (const std::string &collect_header : collect_headers) {
-      lower_case_collect_headers.insert(str_lower_case(collect_header));
-    }
-    return this->perform(url, method, body, request_headers, lower_case_collect_headers);
-  }
+  virtual std::shared_ptr<HttpContainer> start(std::string url, std::string method, std::string body,
+                                               std::list<Header> headers) = 0;
 
  protected:
-  virtual std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
-                                                 std::list<Header> request_headers,
-                                                 std::set<std::string> collect_headers) = 0;
   const char *useragent_{nullptr};
   bool follow_redirects_{};
   uint16_t redirect_limit_{};
@@ -185,11 +149,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   TEMPLATABLE_VALUE(std::string, body)
   TEMPLATABLE_VALUE(bool, capture_response)
 
-  void add_request_header(const char *key, TemplatableValue<const char *, Ts...> value) {
-    this->request_headers_.insert({key, value});
-  }
-
-  void add_collect_header(const char *value) { this->collect_headers_.insert(value); }
+  void add_header(const char *key, TemplatableValue<const char *, Ts...> value) { this->headers_.insert({key, value}); }
 
   void add_json(const char *key, TemplatableValue<std::string, Ts...> value) { this->json_.insert({key, value}); }
 
@@ -216,17 +176,16 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
       auto f = std::bind(&HttpRequestSendAction<Ts...>::encode_json_func_, this, x..., std::placeholders::_1);
       body = json::build_json(f);
     }
-    std::list<Header> request_headers;
-    for (const auto &item : this->request_headers_) {
+    std::list<Header> headers;
+    for (const auto &item : this->headers_) {
       auto val = item.second;
       Header header;
       header.name = item.first;
       header.value = val.value(x...);
-      request_headers.push_back(header);
+      headers.push_back(header);
     }
 
-    auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, request_headers,
-                                          this->collect_headers_);
+    auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, headers);
 
     if (container == nullptr) {
       for (auto *trigger : this->error_triggers_)
@@ -279,8 +238,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   }
   void encode_json_func_(Ts... x, JsonObject root) { this->json_func_(x..., root); }
   HttpRequestComponent *parent_;
-  std::map<const char *, TemplatableValue<const char *, Ts...>> request_headers_{};
-  std::set<std::string> collect_headers_{"content-type", "content-length"};
+  std::map<const char *, TemplatableValue<const char *, Ts...>> headers_{};
   std::map<const char *, TemplatableValue<std::string, Ts...>> json_{};
   std::function<void(Ts..., JsonObject)> json_func_{nullptr};
   std::vector<HttpRequestResponseTrigger *> response_triggers_{};

esphome/components/http_request/http_request_arduino.cpp

@@ -14,9 +14,8 @@ namespace http_request {
 
 static const char *const TAG = "http_request.arduino";
 
-std::shared_ptr<HttpContainer> HttpRequestArduino::perform(std::string url, std::string method, std::string body,
-                                                           std::list<Header> request_headers,
-                                                           std::set<std::string> collect_headers) {
+std::shared_ptr<HttpContainer> HttpRequestArduino::start(std::string url, std::string method, std::string body,
+                                                         std::list<Header> headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);
     ESP_LOGW(TAG, "HTTP Request failed; Not connected to network");
@@ -96,17 +95,14 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(std::string url, std:
   if (this->useragent_ != nullptr) {
     container->client_.setUserAgent(this->useragent_);
   }
-  for (const auto &header : request_headers) {
+  for (const auto &header : headers) {
     container->client_.addHeader(header.name.c_str(), header.value.c_str(), false, true);
   }
 
   // returned needed headers must be collected before the requests
-  const char *header_keys[collect_headers.size()];
-  int index = 0;
-  for (auto const &header_name : collect_headers) {
-    header_keys[index++] = header_name.c_str();
-  }
-  container->client_.collectHeaders(header_keys, index);
+  static const char *header_keys[] = {"Content-Length", "Content-Type"};
+  static const size_t HEADER_COUNT = sizeof(header_keys) / sizeof(header_keys[0]);
+  container->client_.collectHeaders(header_keys, HEADER_COUNT);
 
   App.feed_wdt();
   container->status_code = container->client_.sendRequest(method.c_str(), body.c_str());
@@ -125,18 +121,6 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(std::string url, std:
     // Still return the container, so it can be used to get the status code and error message
   }
 
-  container->response_headers_ = {};
-  auto header_count = container->client_.headers();
-  for (int i = 0; i < header_count; i++) {
-    const std::string header_name = str_lower_case(container->client_.headerName(i).c_str());
-    if (collect_headers.count(header_name) > 0) {
-      std::string header_value = container->client_.header(i).c_str();
-      ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
-      container->response_headers_[header_name].push_back(header_value);
-      break;
-    }
-  }
-
   int content_length = container->client_.getSize();
   ESP_LOGD(TAG, "Content-Length: %d", content_length);
   container->content_length = (size_t) content_length;

esphome/components/http_request/http_request_arduino.h

@@ -29,10 +29,9 @@ class HttpContainerArduino : public HttpContainer {
 };
 
 class HttpRequestArduino : public HttpRequestComponent {
- protected:
-  std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
-                                         std::list<Header> request_headers,
-                                         std::set<std::string> collect_headers) override;
+ public:
+  std::shared_ptr<HttpContainer> start(std::string url, std::string method, std::string body,
+                                       std::list<Header> headers) override;
 };
 
 }  // namespace http_request

esphome/components/http_request/http_request_host.cpp

@@ -1,141 +0,0 @@
-#include "http_request_host.h"
-
-#ifdef USE_HOST
-
-#include <regex>
-#include "esphome/components/network/util.h"
-#include "esphome/components/watchdog/watchdog.h"
-
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace http_request {
-
-static const char *const TAG = "http_request.host";
-
-std::shared_ptr<HttpContainer> HttpRequestHost::perform(std::string url, std::string method, std::string body,
-                                                        std::list<Header> request_headers,
-                                                        std::set<std::string> response_headers) {
-  if (!network::is_connected()) {
-    this->status_momentary_error("failed", 1000);
-    ESP_LOGW(TAG, "HTTP Request failed; Not connected to network");
-    return nullptr;
-  }
-
-  std::regex url_regex(R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)", std::regex::extended);
-  std::smatch url_match_result;
-
-  if (!std::regex_match(url, url_match_result, url_regex) || url_match_result.length() < 7) {
-    ESP_LOGE(TAG, "HTTP Request failed; Malformed URL: %s", url.c_str());
-    return nullptr;
-  }
-  auto host = url_match_result[4].str();
-  auto scheme_host = url_match_result[1].str() + url_match_result[3].str();
-  auto path = url_match_result[5].str() + url_match_result[6].str();
-  if (path.empty())
-    path = "/";
-
-  std::shared_ptr<HttpContainerHost> container = std::make_shared<HttpContainerHost>();
-  container->set_parent(this);
-
-  const uint32_t start = millis();
-
-  watchdog::WatchdogManager wdm(this->get_watchdog_timeout());
-
-  httplib::Headers h_headers;
-  h_headers.emplace("Host", host.c_str());
-  h_headers.emplace("User-Agent", this->useragent_);
-  for (const auto &[name, value] : request_headers) {
-    h_headers.emplace(name, value);
-  }
-  httplib::Client client(scheme_host.c_str());
-  if (!client.is_valid()) {
-    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url.c_str());
-    return nullptr;
-  }
-  client.set_follow_location(this->follow_redirects_);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-  if (this->ca_path_ != nullptr)
-    client.set_ca_cert_path(this->ca_path_);
-#endif
-
-  httplib::Result result;
-  if (method == "GET") {
-    result = client.Get(path, h_headers, [&](const char *data, size_t data_length) {
-      ESP_LOGV(TAG, "Got data length: %zu", data_length);
-      container->response_body_.insert(container->response_body_.end(), (const uint8_t *) data,
-                                       (const uint8_t *) data + data_length);
-      return true;
-    });
-  } else if (method == "HEAD") {
-    result = client.Head(path, h_headers);
-  } else if (method == "PUT") {
-    result = client.Put(path, h_headers, body, "");
-    if (result) {
-      auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
-      container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
-    }
-  } else if (method == "PATCH") {
-    result = client.Patch(path, h_headers, body, "");
-    if (result) {
-      auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
-      container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
-    }
-  } else if (method == "POST") {
-    result = client.Post(path, h_headers, body, "");
-    if (result) {
-      auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
-      container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
-    }
-  } else {
-    ESP_LOGW(TAG, "HTTP Request failed - unsupported method %s; URL: %s", method.c_str(), url.c_str());
-    container->end();
-    return nullptr;
-  }
-  App.feed_wdt();
-  if (!result) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s, error code: %u", url.c_str(), (unsigned) result.error());
-    container->end();
-    this->status_momentary_error("failed", 1000);
-    return nullptr;
-  }
-  App.feed_wdt();
-  auto response = *result;
-  container->status_code = response.status;
-  if (!is_success(response.status)) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), response.status);
-    this->status_momentary_error("failed", 1000);
-    // Still return the container, so it can be used to get the status code and error message
-  }
-
-  container->content_length = container->response_body_.size();
-  for (auto header : response.headers) {
-    ESP_LOGD(TAG, "Header: %s: %s", header.first.c_str(), header.second.c_str());
-    auto lower_name = str_lower_case(header.first);
-    if (response_headers.find(lower_name) != response_headers.end()) {
-      container->response_headers_[lower_name].emplace_back(header.second);
-    }
-  }
-  container->duration_ms = millis() - start;
-  return container;
-}
-
-int HttpContainerHost::read(uint8_t *buf, size_t max_len) {
-  auto bytes_remaining = this->response_body_.size() - this->bytes_read_;
-  auto read_len = std::min(max_len, bytes_remaining);
-  memcpy(buf, this->response_body_.data() + this->bytes_read_, read_len);
-  this->bytes_read_ += read_len;
-  return read_len;
-}
-
-void HttpContainerHost::end() {
-  watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
-  this->response_body_ = std::vector<uint8_t>();
-  this->bytes_read_ = 0;
-}
-
-}  // namespace http_request
-}  // namespace esphome
-
-#endif  // USE_HOST

esphome/components/http_request/http_request_host.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include "http_request.h"
-
-#ifdef USE_HOST
-
-#define CPPHTTPLIB_NO_EXCEPTIONS
-#include "httplib.h"
-namespace esphome {
-namespace http_request {
-
-class HttpRequestHost;
-class HttpContainerHost : public HttpContainer {
- public:
-  int read(uint8_t *buf, size_t max_len) override;
-  void end() override;
-
- protected:
-  friend class HttpRequestHost;
-  std::vector<uint8_t> response_body_{};
-};
-
-class HttpRequestHost : public HttpRequestComponent {
- public:
-  std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
-                                         std::list<Header> request_headers,
-                                         std::set<std::string> response_headers) override;
-  void set_ca_path(const char *ca_path) { this->ca_path_ = ca_path; }
-
- protected:
-  const char *ca_path_{};
-};
-
-}  // namespace http_request
-}  // namespace esphome
-
-#endif  // USE_HOST

esphome/components/http_request/http_request_idf.cpp

@@ -19,41 +19,14 @@ namespace http_request {
 
 static const char *const TAG = "http_request.idf";
 
-struct UserData {
-  const std::set<std::string> &collect_headers;
-  std::map<std::string, std::list<std::string>> response_headers;
-};
-
 void HttpRequestIDF::dump_config() {
   HttpRequestComponent::dump_config();
   ESP_LOGCONFIG(TAG, "  Buffer Size RX: %u", this->buffer_size_rx_);
   ESP_LOGCONFIG(TAG, "  Buffer Size TX: %u", this->buffer_size_tx_);
 }
 
-esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
-  UserData *user_data = (UserData *) evt->user_data;
-
-  switch (evt->event_id) {
-    case HTTP_EVENT_ON_HEADER: {
-      const std::string header_name = str_lower_case(evt->header_key);
-      if (user_data->collect_headers.count(header_name)) {
-        const std::string header_value = evt->header_value;
-        ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
-        user_data->response_headers[header_name].push_back(header_value);
-        break;
-      }
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-  return ESP_OK;
-}
-
-std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::string method, std::string body,
-                                                       std::list<Header> request_headers,
-                                                       std::set<std::string> collect_headers) {
+std::shared_ptr<HttpContainer> HttpRequestIDF::start(std::string url, std::string method, std::string body,
+                                                     std::list<Header> headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);
     ESP_LOGE(TAG, "HTTP Request failed; Not connected to network");
@@ -103,10 +76,6 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::str
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->get_watchdog_timeout());
 
-  config.event_handler = http_event_handler;
-  auto user_data = UserData{collect_headers, {}};
-  config.user_data = static_cast<void *>(&user_data);
-
   esp_http_client_handle_t client = esp_http_client_init(&config);
 
   std::shared_ptr<HttpContainerIDF> container = std::make_shared<HttpContainerIDF>(client);
@@ -114,7 +83,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::str
 
   container->set_secure(secure);
 
-  for (const auto &header : request_headers) {
+  for (const auto &header : headers) {
     esp_http_client_set_header(client, header.name.c_str(), header.value.c_str());
   }
 
@@ -155,7 +124,6 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::str
   container->feed_wdt();
   container->status_code = esp_http_client_get_status_code(client);
   container->feed_wdt();
-  container->set_response_headers(user_data.response_headers);
   if (is_success(container->status_code)) {
     container->duration_ms = millis() - start;
     return container;

esphome/components/http_request/http_request_idf.h

@@ -21,10 +21,6 @@ class HttpContainerIDF : public HttpContainer {
   /// @brief Feeds the watchdog timer if the executing task has one attached
   void feed_wdt();
 
-  void set_response_headers(std::map<std::string, std::list<std::string>> &response_headers) {
-    this->response_headers_ = std::move(response_headers);
-  }
-
  protected:
   esp_http_client_handle_t client_;
 };
@@ -33,19 +29,16 @@ class HttpRequestIDF : public HttpRequestComponent {
  public:
   void dump_config() override;
 
+  std::shared_ptr<HttpContainer> start(std::string url, std::string method, std::string body,
+                                       std::list<Header> headers) override;
+
   void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
   void set_buffer_size_tx(uint16_t buffer_size_tx) { this->buffer_size_tx_ = buffer_size_tx; }
 
  protected:
-  std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
-                                         std::list<Header> request_headers,
-                                         std::set<std::string> collect_headers) override;
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
   uint16_t buffer_size_rx_{};
   uint16_t buffer_size_tx_{};
-
-  /// @brief Monitors the http client events to gather response headers
-  static esp_err_t http_event_handler(esp_http_client_event_t *evt);
 };
 
 }  // namespace http_request

esphome/components/i2s_audio/__init__.py

@@ -8,15 +8,7 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32S3,
 )
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BITS_PER_SAMPLE,
-    CONF_CHANNEL,
-    CONF_ID,
-    CONF_SAMPLE_RATE,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
-)
-from esphome.core import CORE
+from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
 from esphome.cpp_generator import MockObjClass
 import esphome.final_validate as fv
 
@@ -43,9 +35,6 @@ CONF_MONO = "mono"
 CONF_LEFT = "left"
 CONF_RIGHT = "right"
 CONF_STEREO = "stereo"
-CONF_BOTH = "both"
-
-CONF_USE_LEGACY = "use_legacy"
 
 i2s_audio_ns = cg.esphome_ns.namespace("i2s_audio")
 I2SAudioComponent = i2s_audio_ns.class_("I2SAudioComponent", cg.Component)
@@ -61,12 +50,6 @@ I2S_MODE_OPTIONS = {
     CONF_SECONDARY: i2s_mode_t.I2S_MODE_SLAVE,  # NOLINT
 }
 
-i2s_role_t = cg.global_ns.enum("i2s_role_t")
-I2S_ROLE_OPTIONS = {
-    CONF_PRIMARY: i2s_role_t.I2S_ROLE_MASTER,  # NOLINT
-    CONF_SECONDARY: i2s_role_t.I2S_ROLE_SLAVE,  # NOLINT
-}
-
 # https://github.com/espressif/esp-idf/blob/master/components/soc/{variant}/include/soc/soc_caps.h
 I2S_PORTS = {
     VARIANT_ESP32: 2,
@@ -77,23 +60,10 @@ I2S_PORTS = {
 
 i2s_channel_fmt_t = cg.global_ns.enum("i2s_channel_fmt_t")
 I2S_CHANNELS = {
-    CONF_MONO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ALL_LEFT,  # left data to both channels
-    CONF_LEFT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_LEFT,  # mono data
-    CONF_RIGHT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_RIGHT,  # mono data
-    CONF_STEREO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_RIGHT_LEFT,  # stereo data to both channels
-}
-
-i2s_slot_mode_t = cg.global_ns.enum("i2s_slot_mode_t")
-I2S_SLOT_MODE = {
-    CONF_MONO: i2s_slot_mode_t.I2S_SLOT_MODE_MONO,
-    CONF_STEREO: i2s_slot_mode_t.I2S_SLOT_MODE_STEREO,
-}
-
-i2s_std_slot_mask_t = cg.global_ns.enum("i2s_std_slot_mask_t")
-I2S_STD_SLOT_MASK = {
-    CONF_LEFT: i2s_std_slot_mask_t.I2S_STD_SLOT_LEFT,
-    CONF_RIGHT: i2s_std_slot_mask_t.I2S_STD_SLOT_RIGHT,
-    CONF_BOTH: i2s_std_slot_mask_t.I2S_STD_SLOT_BOTH,
+    CONF_MONO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ALL_LEFT,
+    CONF_LEFT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_LEFT,
+    CONF_RIGHT: i2s_channel_fmt_t.I2S_CHANNEL_FMT_ONLY_RIGHT,
+    CONF_STEREO: i2s_channel_fmt_t.I2S_CHANNEL_FMT_RIGHT_LEFT,
 }
 
 i2s_bits_per_sample_t = cg.global_ns.enum("i2s_bits_per_sample_t")
@@ -113,19 +83,8 @@ I2S_BITS_PER_CHANNEL = {
     32: i2s_bits_per_chan_t.I2S_BITS_PER_CHAN_32BIT,
 }
 
-i2s_slot_bit_width_t = cg.global_ns.enum("i2s_slot_bit_width_t")
-I2S_SLOT_BIT_WIDTH = {
-    "default": i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_AUTO,
-    8: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_8BIT,
-    16: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_16BIT,
-    24: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_24BIT,
-    32: i2s_slot_bit_width_t.I2S_SLOT_BIT_WIDTH_32BIT,
-}
-
 _validate_bits = cv.float_with_unit("bits", "bit")
 
-_use_legacy_driver = None
-
 
 def i2s_audio_component_schema(
     class_: MockObjClass,
@@ -138,22 +97,20 @@ def i2s_audio_component_schema(
         {
             cv.GenerateID(): cv.declare_id(class_),
             cv.GenerateID(CONF_I2S_AUDIO_ID): cv.use_id(I2SAudioComponent),
-            cv.Optional(CONF_CHANNEL, default=default_channel): cv.one_of(
-                *I2S_CHANNELS
-            ),
+            cv.Optional(CONF_CHANNEL, default=default_channel): cv.enum(I2S_CHANNELS),
             cv.Optional(CONF_SAMPLE_RATE, default=default_sample_rate): cv.int_range(
                 min=1
             ),
             cv.Optional(CONF_BITS_PER_SAMPLE, default=default_bits_per_sample): cv.All(
-                _validate_bits, cv.one_of(*I2S_BITS_PER_SAMPLE)
+                _validate_bits, cv.enum(I2S_BITS_PER_SAMPLE)
             ),
-            cv.Optional(CONF_I2S_MODE, default=CONF_PRIMARY): cv.one_of(
-                *I2S_MODE_OPTIONS, lower=True
+            cv.Optional(CONF_I2S_MODE, default=CONF_PRIMARY): cv.enum(
+                I2S_MODE_OPTIONS, lower=True
             ),
             cv.Optional(CONF_USE_APLL, default=False): cv.boolean,
             cv.Optional(CONF_BITS_PER_CHANNEL, default="default"): cv.All(
                 cv.Any(cv.float_with_unit("bits", "bit"), "default"),
-                cv.one_of(*I2S_BITS_PER_CHANNEL),
+                cv.enum(I2S_BITS_PER_CHANNEL),
             ),
         }
     )
@@ -161,60 +118,22 @@ def i2s_audio_component_schema(
 
 async def register_i2s_audio_component(var, config):
     await cg.register_parented(var, config[CONF_I2S_AUDIO_ID])
-    if use_legacy():
-        cg.add(var.set_i2s_mode(I2S_MODE_OPTIONS[config[CONF_I2S_MODE]]))
-        cg.add(var.set_channel(I2S_CHANNELS[config[CONF_CHANNEL]]))
-        cg.add(
-            var.set_bits_per_sample(I2S_BITS_PER_SAMPLE[config[CONF_BITS_PER_SAMPLE]])
-        )
-        cg.add(
-            var.set_bits_per_channel(
-                I2S_BITS_PER_CHANNEL[config[CONF_BITS_PER_CHANNEL]]
-            )
-        )
-    else:
-        cg.add(var.set_i2s_role(I2S_ROLE_OPTIONS[config[CONF_I2S_MODE]]))
-        slot_mode = config[CONF_CHANNEL]
-        if slot_mode != CONF_STEREO:
-            slot_mode = CONF_MONO
-        slot_mask = config[CONF_CHANNEL]
-        if slot_mask not in [CONF_LEFT, CONF_RIGHT]:
-            slot_mask = CONF_BOTH
-        cg.add(var.set_slot_mode(I2S_SLOT_MODE[slot_mode]))
-        cg.add(var.set_std_slot_mask(I2S_STD_SLOT_MASK[slot_mask]))
-        cg.add(
-            var.set_slot_bit_width(I2S_SLOT_BIT_WIDTH[config[CONF_BITS_PER_CHANNEL]])
-        )
+
+    cg.add(var.set_i2s_mode(config[CONF_I2S_MODE]))
+    cg.add(var.set_channel(config[CONF_CHANNEL]))
     cg.add(var.set_sample_rate(config[CONF_SAMPLE_RATE]))
+    cg.add(var.set_bits_per_sample(config[CONF_BITS_PER_SAMPLE]))
+    cg.add(var.set_bits_per_channel(config[CONF_BITS_PER_CHANNEL]))
     cg.add(var.set_use_apll(config[CONF_USE_APLL]))
 
 
-def validate_use_legacy(value):
-    global _use_legacy_driver  # noqa: PLW0603
-    if CONF_USE_LEGACY in value:
-        if (_use_legacy_driver is not None) and (
-            _use_legacy_driver != value[CONF_USE_LEGACY]
-        ):
-            raise cv.Invalid(
-                f"All i2s_audio components must set {CONF_USE_LEGACY} to the same value."
-            )
-        if (not value[CONF_USE_LEGACY]) and (CORE.using_arduino):
-            raise cv.Invalid("Arduino supports only the legacy i2s driver.")
-        _use_legacy_driver = value[CONF_USE_LEGACY]
-    return value
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(I2SAudioComponent),
-            cv.Required(CONF_I2S_LRCLK_PIN): pins.internal_gpio_output_pin_number,
-            cv.Optional(CONF_I2S_BCLK_PIN): pins.internal_gpio_output_pin_number,
-            cv.Optional(CONF_I2S_MCLK_PIN): pins.internal_gpio_output_pin_number,
-            cv.Optional(CONF_USE_LEGACY): cv.boolean,
-        },
-    ),
-    validate_use_legacy,
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(I2SAudioComponent),
+        cv.Required(CONF_I2S_LRCLK_PIN): pins.internal_gpio_output_pin_number,
+        cv.Optional(CONF_I2S_BCLK_PIN): pins.internal_gpio_output_pin_number,
+        cv.Optional(CONF_I2S_MCLK_PIN): pins.internal_gpio_output_pin_number,
+    }
 )
 
 
@@ -229,22 +148,12 @@ def _final_validate(_):
         )
 
 
-def use_legacy():
-    framework_version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
-    if CORE.using_esp_idf and framework_version >= cv.Version(5, 0, 0):
-        if not _use_legacy_driver:
-            return False
-    return True
-
-
 FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    if use_legacy():
-        cg.add_define("USE_I2S_LEGACY")
 
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:

esphome/components/i2s_audio/i2s_audio.h

@@ -2,14 +2,9 @@
 
 #ifdef USE_ESP32
 
+#include <driver/i2s.h>
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/defines.h"
-#ifdef USE_I2S_LEGACY
-#include <driver/i2s.h>
-#else
-#include <driver/i2s_std.h>
-#endif
 
 namespace esphome {
 namespace i2s_audio {
@@ -18,33 +13,19 @@ class I2SAudioComponent;
 
 class I2SAudioBase : public Parented<I2SAudioComponent> {
  public:
-#ifdef USE_I2S_LEGACY
   void set_i2s_mode(i2s_mode_t mode) { this->i2s_mode_ = mode; }
   void set_channel(i2s_channel_fmt_t channel) { this->channel_ = channel; }
+  void set_sample_rate(uint32_t sample_rate) { this->sample_rate_ = sample_rate; }
   void set_bits_per_sample(i2s_bits_per_sample_t bits_per_sample) { this->bits_per_sample_ = bits_per_sample; }
   void set_bits_per_channel(i2s_bits_per_chan_t bits_per_channel) { this->bits_per_channel_ = bits_per_channel; }
-#else
-  void set_i2s_role(i2s_role_t role) { this->i2s_role_ = role; }
-  void set_slot_mode(i2s_slot_mode_t slot_mode) { this->slot_mode_ = slot_mode; }
-  void set_std_slot_mask(i2s_std_slot_mask_t std_slot_mask) { this->std_slot_mask_ = std_slot_mask; }
-  void set_slot_bit_width(i2s_slot_bit_width_t slot_bit_width) { this->slot_bit_width_ = slot_bit_width; }
-#endif
-  void set_sample_rate(uint32_t sample_rate) { this->sample_rate_ = sample_rate; }
   void set_use_apll(uint32_t use_apll) { this->use_apll_ = use_apll; }
 
  protected:
-#ifdef USE_I2S_LEGACY
   i2s_mode_t i2s_mode_{};
   i2s_channel_fmt_t channel_;
+  uint32_t sample_rate_;
   i2s_bits_per_sample_t bits_per_sample_;
   i2s_bits_per_chan_t bits_per_channel_;
-#else
-  i2s_role_t i2s_role_{};
-  i2s_slot_mode_t slot_mode_;
-  i2s_std_slot_mask_t std_slot_mask_;
-  i2s_slot_bit_width_t slot_bit_width_;
-#endif
-  uint32_t sample_rate_;
   bool use_apll_;
 };
 
@@ -56,7 +37,6 @@ class I2SAudioComponent : public Component {
  public:
   void setup() override;
 
-#ifdef USE_I2S_LEGACY
   i2s_pin_config_t get_pin_config() const {
     return {
         .mck_io_num = this->mclk_pin_,
@@ -66,20 +46,6 @@ class I2SAudioComponent : public Component {
         .data_in_num = I2S_PIN_NO_CHANGE,
     };
   }
-#else
-  i2s_std_gpio_config_t get_pin_config() const {
-    return {.mclk = (gpio_num_t) this->mclk_pin_,
-            .bclk = (gpio_num_t) this->bclk_pin_,
-            .ws = (gpio_num_t) this->lrclk_pin_,
-            .dout = I2S_GPIO_UNUSED,  // add local ports
-            .din = I2S_GPIO_UNUSED,
-            .invert_flags = {
-                .mclk_inv = false,
-                .bclk_inv = false,
-                .ws_inv = false,
-            }};
-  }
-#endif
 
   void set_mclk_pin(int pin) { this->mclk_pin_ = pin; }
   void set_bclk_pin(int pin) { this->bclk_pin_ = pin; }
@@ -96,13 +62,9 @@ class I2SAudioComponent : public Component {
 
   I2SAudioIn *audio_in_{nullptr};
   I2SAudioOut *audio_out_{nullptr};
-#ifdef USE_I2S_LEGACY
+
   int mclk_pin_{I2S_PIN_NO_CHANGE};
   int bclk_pin_{I2S_PIN_NO_CHANGE};
-#else
-  int mclk_pin_{I2S_GPIO_UNUSED};
-  int bclk_pin_{I2S_GPIO_UNUSED};
-#endif
   int lrclk_pin_;
   i2s_port_t port_{};
 };

esphome/components/i2s_audio/media_player/__init__.py

@@ -14,7 +14,6 @@ from .. import (
     I2SAudioComponent,
     I2SAudioOut,
     i2s_audio_ns,
-    use_legacy,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -88,14 +87,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(_):
-    if not use_legacy():
-        raise cv.Invalid("I2S media player is only compatible with legacy i2s driver.")
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/i2s_audio/microphone/__init__.py

@@ -6,15 +6,12 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_NUMBER
 
 from .. import (
-    CONF_CHANNEL,
     CONF_I2S_DIN_PIN,
-    CONF_MONO,
     CONF_RIGHT,
     I2SAudioIn,
     i2s_audio_component_schema,
     i2s_audio_ns,
     register_i2s_audio_component,
-    use_legacy,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -46,12 +43,6 @@ def validate_esp32_variant(config):
     raise NotImplementedError
 
 
-def validate_channel(config):
-    if config[CONF_CHANNEL] == CONF_MONO:
-        raise cv.Invalid(f"I2S microphone does not support {CONF_MONO}.")
-    return config
-
-
 BASE_SCHEMA = microphone.MICROPHONE_SCHEMA.extend(
     i2s_audio_component_schema(
         I2SAudioMicrophone,
@@ -80,19 +71,9 @@ CONFIG_SCHEMA = cv.All(
         key=CONF_ADC_TYPE,
     ),
     validate_esp32_variant,
-    validate_channel,
 )
 
 
-def _final_validate(config):
-    if not use_legacy():
-        if config[CONF_ADC_TYPE] == "internal":
-            raise cv.Invalid("Internal ADC is only compatible with legacy i2s driver.")
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/i2s_audio/microphone/i2s_audio_microphone.cpp

@@ -2,12 +2,7 @@
 
 #ifdef USE_ESP32
 
-#ifdef USE_I2S_LEGACY
 #include <driver/i2s.h>
-#else
-#include <driver/i2s_std.h>
-#include <driver/i2s_pdm.h>
-#endif
 
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -21,7 +16,6 @@ static const char *const TAG = "i2s_audio.microphone";
 
 void I2SAudioMicrophone::setup() {
   ESP_LOGCONFIG(TAG, "Setting up I2S Audio Microphone...");
-#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     if (this->parent_->get_port() != I2S_NUM_0) {
@@ -30,7 +24,6 @@ void I2SAudioMicrophone::setup() {
       return;
     }
   } else
-#endif
 #endif
   {
     if (this->pdm_) {
@@ -54,9 +47,6 @@ void I2SAudioMicrophone::start_() {
   if (!this->parent_->try_lock()) {
     return;  // Waiting for another i2s to return lock
   }
-  esp_err_t err;
-
-#ifdef USE_I2S_LEGACY
   i2s_driver_config_t config = {
       .mode = (i2s_mode_t) (this->i2s_mode_ | I2S_MODE_RX),
       .sample_rate = this->sample_rate_,
@@ -73,6 +63,8 @@ void I2SAudioMicrophone::start_() {
       .bits_per_chan = this->bits_per_channel_,
   };
 
+  esp_err_t err;
+
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     config.mode = (i2s_mode_t) (config.mode | I2S_MODE_ADC_BUILT_IN);
@@ -119,109 +111,6 @@ void I2SAudioMicrophone::start_() {
       return;
     }
   }
-#else
-  i2s_chan_config_t chan_cfg = {
-      .id = this->parent_->get_port(),
-      .role = this->i2s_role_,
-      .dma_desc_num = 4,
-      .dma_frame_num = 256,
-      .auto_clear = false,
-  };
-  /* Allocate a new RX channel and get the handle of this channel */
-  err = i2s_new_channel(&chan_cfg, NULL, &this->rx_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error creating new I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
-  }
-
-  i2s_clock_src_t clk_src = I2S_CLK_SRC_DEFAULT;
-#ifdef I2S_CLK_SRC_APLL
-  if (this->use_apll_) {
-    clk_src = I2S_CLK_SRC_APLL;
-  }
-#endif
-  i2s_std_gpio_config_t pin_config = this->parent_->get_pin_config();
-#if SOC_I2S_SUPPORTS_PDM_RX
-  if (this->pdm_) {
-    i2s_pdm_rx_clk_config_t clk_cfg = {
-        .sample_rate_hz = this->sample_rate_,
-        .clk_src = clk_src,
-        .mclk_multiple = I2S_MCLK_MULTIPLE_256,
-        .dn_sample_mode = I2S_PDM_DSR_8S,
-    };
-
-    i2s_pdm_rx_slot_config_t slot_cfg = I2S_PDM_RX_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, this->slot_mode_);
-    switch (this->std_slot_mask_) {
-      case I2S_STD_SLOT_LEFT:
-        slot_cfg.slot_mask = I2S_PDM_SLOT_LEFT;
-        break;
-      case I2S_STD_SLOT_RIGHT:
-        slot_cfg.slot_mask = I2S_PDM_SLOT_RIGHT;
-        break;
-      case I2S_STD_SLOT_BOTH:
-        slot_cfg.slot_mask = I2S_PDM_SLOT_BOTH;
-        break;
-    }
-
-    /* Init the channel into PDM RX mode */
-    i2s_pdm_rx_config_t pdm_rx_cfg = {
-        .clk_cfg = clk_cfg,
-        .slot_cfg = slot_cfg,
-        .gpio_cfg =
-            {
-                .clk = pin_config.ws,
-                .din = this->din_pin_,
-                .invert_flags =
-                    {
-                        .clk_inv = pin_config.invert_flags.ws_inv,
-                    },
-            },
-    };
-    err = i2s_channel_init_pdm_rx_mode(this->rx_handle_, &pdm_rx_cfg);
-  } else
-#endif
-  {
-    i2s_std_clk_config_t clk_cfg = {
-        .sample_rate_hz = this->sample_rate_,
-        .clk_src = clk_src,
-        .mclk_multiple = I2S_MCLK_MULTIPLE_256,
-    };
-    i2s_data_bit_width_t data_bit_width;
-    if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_8BIT) {
-      data_bit_width = I2S_DATA_BIT_WIDTH_16BIT;
-    } else {
-      data_bit_width = I2S_DATA_BIT_WIDTH_8BIT;
-    }
-    i2s_std_slot_config_t std_slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG(data_bit_width, this->slot_mode_);
-    std_slot_cfg.slot_bit_width = this->slot_bit_width_;
-    std_slot_cfg.slot_mask = this->std_slot_mask_;
-
-    pin_config.din = this->din_pin_;
-
-    i2s_std_config_t std_cfg = {
-        .clk_cfg = clk_cfg,
-        .slot_cfg = std_slot_cfg,
-        .gpio_cfg = pin_config,
-    };
-    /* Initialize the channel */
-    err = i2s_channel_init_std_mode(this->rx_handle_, &std_cfg);
-  }
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error initializing I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
-  }
-
-  /* Before reading data, start the RX channel first */
-  i2s_channel_enable(this->rx_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error enabling I2S Microphone: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
-  }
-#endif
-
   this->state_ = microphone::STATE_RUNNING;
   this->high_freq_.start();
   this->status_clear_error();
@@ -239,7 +128,6 @@ void I2SAudioMicrophone::stop() {
 
 void I2SAudioMicrophone::stop_() {
   esp_err_t err;
-#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   if (this->adc_) {
     err = i2s_adc_disable(this->parent_->get_port());
@@ -262,50 +150,27 @@ void I2SAudioMicrophone::stop_() {
     this->status_set_error();
     return;
   }
-#else
-  /* Have to stop the channel before deleting it */
-  err = i2s_channel_disable(this->rx_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error stopping I2S microphone: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
-  }
-  /* If the handle is not needed any more, delete it to release the channel resources */
-  err = i2s_del_channel(this->rx_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Error deleting I2S channel: %s", esp_err_to_name(err));
-    this->status_set_error();
-    return;
-  }
-#endif
   this->parent_->unlock();
   this->state_ = microphone::STATE_STOPPED;
   this->high_freq_.stop();
   this->status_clear_error();
 }
 
-size_t I2SAudioMicrophone::read(int16_t *buf, size_t len, TickType_t ticks_to_wait) {
+size_t I2SAudioMicrophone::read(int16_t *buf, size_t len) {
   size_t bytes_read = 0;
-#ifdef USE_I2S_LEGACY
-  esp_err_t err = i2s_read(this->parent_->get_port(), buf, len, &bytes_read, ticks_to_wait);
-#else
-  // i2s_channel_read expects the timeout value in ms, not ticks
-  esp_err_t err = i2s_channel_read(this->rx_handle_, buf, len, &bytes_read, pdTICKS_TO_MS(ticks_to_wait));
-#endif
-  if ((err != ESP_OK) && ((err != ESP_ERR_TIMEOUT) || (ticks_to_wait != 0))) {
-    // Ignore ESP_ERR_TIMEOUT if ticks_to_wait = 0, as it will read the data on the next call
+  esp_err_t err = i2s_read(this->parent_->get_port(), buf, len, &bytes_read, (100 / portTICK_PERIOD_MS));
+  if (err != ESP_OK) {
     ESP_LOGW(TAG, "Error reading from I2S microphone: %s", esp_err_to_name(err));
     this->status_set_warning();
     return 0;
   }
-  if ((bytes_read == 0) && (ticks_to_wait > 0)) {
+  if (bytes_read == 0) {
     this->status_set_warning();
     return 0;
   }
   this->status_clear_warning();
   // ESP-IDF I2S implementation right-extends 8-bit data to 16 bits,
   // and 24-bit data to 32 bits.
-#ifdef USE_I2S_LEGACY
   switch (this->bits_per_sample_) {
     case I2S_BITS_PER_SAMPLE_8BIT:
     case I2S_BITS_PER_SAMPLE_16BIT:
@@ -323,36 +188,12 @@ size_t I2SAudioMicrophone::read(int16_t *buf, size_t len, TickType_t ticks_to_wa
       ESP_LOGE(TAG, "Unsupported bits per sample: %d", this->bits_per_sample_);
       return 0;
   }
-#else
-#ifndef USE_ESP32_VARIANT_ESP32
-  // For newer ESP32 variants 8 bit data needs to be extended to 16 bit.
-  if (this->slot_bit_width_ == I2S_SLOT_BIT_WIDTH_8BIT) {
-    size_t samples_read = bytes_read / sizeof(int8_t);
-    for (size_t i = samples_read - 1; i >= 0; i--) {
-      int16_t temp = static_cast<int16_t>(reinterpret_cast<int8_t *>(buf)[i]) << 8;
-      buf[i] = temp;
-    }
-    return samples_read * sizeof(int16_t);
-  }
-#else
-  // For ESP32 8/16 bit standard mono mode samples need to be switched.
-  if (this->slot_mode_ == I2S_SLOT_MODE_MONO && this->slot_bit_width_ <= 16 && !this->pdm_) {
-    size_t samples_read = bytes_read / sizeof(int16_t);
-    for (int i = 0; i < samples_read; i += 2) {
-      int16_t tmp = buf[i];
-      buf[i] = buf[i + 1];
-      buf[i + 1] = tmp;
-    }
-  }
-#endif
-  return bytes_read;
-#endif
 }
 
 void I2SAudioMicrophone::read_() {
   std::vector<int16_t> samples;
   samples.resize(BUFFER_SIZE);
-  size_t bytes_read = this->read(samples.data(), BUFFER_SIZE * sizeof(int16_t), 0);
+  size_t bytes_read = this->read(samples.data(), BUFFER_SIZE / sizeof(int16_t));
   samples.resize(bytes_read / sizeof(int16_t));
   this->data_callbacks_.call(samples);
 }

esphome/components/i2s_audio/microphone/i2s_audio_microphone.h

@@ -17,24 +17,17 @@ class I2SAudioMicrophone : public I2SAudioIn, public microphone::Microphone, pub
   void stop() override;
 
   void loop() override;
-#ifdef USE_I2S_LEGACY
-  void set_din_pin(int8_t pin) { this->din_pin_ = pin; }
-#else
-  void set_din_pin(int8_t pin) { this->din_pin_ = (gpio_num_t) pin; }
-#endif
 
+  void set_din_pin(int8_t pin) { this->din_pin_ = pin; }
   void set_pdm(bool pdm) { this->pdm_ = pdm; }
 
-  size_t read(int16_t *buf, size_t len, TickType_t ticks_to_wait);
-  size_t read(int16_t *buf, size_t len) override { return this->read(buf, len, pdMS_TO_TICKS(100)); }
+  size_t read(int16_t *buf, size_t len) override;
 
-#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_ADC
   void set_adc_channel(adc1_channel_t channel) {
     this->adc_channel_ = channel;
     this->adc_ = true;
   }
-#endif
 #endif
 
  protected:
@@ -42,15 +35,10 @@ class I2SAudioMicrophone : public I2SAudioIn, public microphone::Microphone, pub
   void stop_();
   void read_();
 
-#ifdef USE_I2S_LEGACY
   int8_t din_pin_{I2S_PIN_NO_CHANGE};
 #if SOC_I2S_SUPPORTS_ADC
   adc1_channel_t adc_channel_{ADC1_CHANNEL_MAX};
   bool adc_{false};
-#endif
-#else
-  gpio_num_t din_pin_{I2S_GPIO_UNUSED};
-  i2s_chan_handle_t rx_handle_;
 #endif
   bool pdm_{false};
 

esphome/components/i2s_audio/speaker/__init__.py

@@ -26,7 +26,6 @@ from .. import (
     i2s_audio_component_schema,
     i2s_audio_ns,
     register_i2s_audio_component,
-    use_legacy,
 )
 
 AUTO_LOAD = ["audio"]
@@ -61,7 +60,7 @@ I2C_COMM_FMT_OPTIONS = {
     "pcm_long": i2s_comm_format_t.I2S_COMM_FORMAT_PCM_LONG,
 }
 
-INTERNAL_DAC_VARIANTS = [esp32.const.VARIANT_ESP32]
+NO_INTERNAL_DAC_VARIANTS = [esp32.const.VARIANT_ESP32S2]
 
 
 def _set_num_channels_from_config(config):
@@ -102,7 +101,7 @@ def _validate_esp32_variant(config):
     if config[CONF_DAC_TYPE] != "internal":
         return config
     variant = esp32.get_esp32_variant()
-    if variant not in INTERNAL_DAC_VARIANTS:
+    if variant in NO_INTERNAL_DAC_VARIANTS:
         raise cv.Invalid(f"{variant} does not have an internal DAC")
     return config
 
@@ -144,8 +143,8 @@ CONFIG_SCHEMA = cv.All(
                     cv.Required(
                         CONF_I2S_DOUT_PIN
                     ): pins.internal_gpio_output_pin_number,
-                    cv.Optional(CONF_I2S_COMM_FMT, default="stand_i2s"): cv.one_of(
-                        *I2C_COMM_FMT_OPTIONS, lower=True
+                    cv.Optional(CONF_I2S_COMM_FMT, default="stand_i2s"): cv.enum(
+                        I2C_COMM_FMT_OPTIONS, lower=True
                     ),
                 }
             ),
@@ -158,19 +157,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(config):
-    if not use_legacy():
-        if config[CONF_DAC_TYPE] == "internal":
-            raise cv.Invalid("Internal DAC is only compatible with legacy i2s driver.")
-        if config[CONF_I2S_COMM_FMT] == "stand_max":
-            raise cv.Invalid(
-                "I2S standard max format only implemented with legacy i2s driver."
-            )
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
@@ -181,17 +167,7 @@ async def to_code(config):
         cg.add(var.set_internal_dac_mode(config[CONF_CHANNEL]))
     else:
         cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
-        if use_legacy():
-            cg.add(
-                var.set_i2s_comm_fmt(I2C_COMM_FMT_OPTIONS[config[CONF_I2S_COMM_FMT]])
-            )
-        else:
-            fmt = "std"  # equals stand_i2s, stand_pcm_long, i2s_msb, pcm_long
-            if config[CONF_I2S_COMM_FMT] in ["stand_msb", "i2s_lsb"]:
-                fmt = "msb"
-            elif config[CONF_I2S_COMM_FMT] in ["stand_pcm_short", "pcm_short", "pcm"]:
-                fmt = "pcm"
-            cg.add(var.set_i2s_comm_fmt(fmt))
+        cg.add(var.set_i2s_comm_fmt(config[CONF_I2S_COMM_FMT]))
     if config[CONF_TIMEOUT] != CONF_NEVER:
         cg.add(var.set_timeout(config[CONF_TIMEOUT]))
     cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -2,11 +2,7 @@
 
 #ifdef USE_ESP32
 
-#ifdef USE_I2S_LEGACY
 #include <driver/i2s.h>
-#else
-#include <driver/i2s_std.h>
-#endif
 
 #include "esphome/components/audio/audio.h"
 
@@ -298,21 +294,13 @@ void I2SAudioSpeaker::speaker_task(void *params) {
         // Audio stream info changed, stop the speaker task so it will restart with the proper settings.
         break;
       }
-#ifdef USE_I2S_LEGACY
+
       i2s_event_t i2s_event;
       while (xQueueReceive(this_speaker->i2s_event_queue_, &i2s_event, 0)) {
         if (i2s_event.type == I2S_EVENT_TX_Q_OVF) {
           tx_dma_underflow = true;
         }
       }
-#else
-      bool overflow;
-      while (xQueueReceive(this_speaker->i2s_event_queue_, &overflow, 0)) {
-        if (overflow) {
-          tx_dma_underflow = true;
-        }
-      }
-#endif
 
       if (this_speaker->pause_state_) {
         // Pause state is accessed atomically, so thread safe
@@ -331,18 +319,6 @@ void I2SAudioSpeaker::speaker_task(void *params) {
                              bytes_read / sizeof(int16_t), this_speaker->q15_volume_factor_);
         }
 
-#ifdef USE_ESP32_VARIANT_ESP32
-        // For ESP32 8/16 bit mono mode samples need to be switched.
-        if (audio_stream_info.get_channels() == 1 && audio_stream_info.get_bits_per_sample() <= 16) {
-          size_t len = bytes_read / sizeof(int16_t);
-          int16_t *tmp_buf = (int16_t *) this_speaker->data_buffer_;
-          for (int i = 0; i < len; i += 2) {
-            int16_t tmp = tmp_buf[i];
-            tmp_buf[i] = tmp_buf[i + 1];
-            tmp_buf[i + 1] = tmp;
-          }
-        }
-#endif
         // Write the audio data to a single DMA buffer at a time to reduce latency for the audio duration played
         // callback.
         const uint32_t batches = (bytes_read + single_dma_buffer_input_size - 1) / single_dma_buffer_input_size;
@@ -351,7 +327,6 @@ void I2SAudioSpeaker::speaker_task(void *params) {
           size_t bytes_written = 0;
           size_t bytes_to_write = std::min(single_dma_buffer_input_size, bytes_read);
 
-#ifdef USE_I2S_LEGACY
           if (audio_stream_info.get_bits_per_sample() == (uint8_t) this_speaker->bits_per_sample_) {
             i2s_write(this_speaker->parent_->get_port(), this_speaker->data_buffer_ + i * single_dma_buffer_input_size,
                       bytes_to_write, &bytes_written, pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS * 5));
@@ -361,10 +336,6 @@ void I2SAudioSpeaker::speaker_task(void *params) {
                              audio_stream_info.get_bits_per_sample(), this_speaker->bits_per_sample_, &bytes_written,
                              pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS * 5));
           }
-#else
-          i2s_channel_write(this_speaker->tx_handle_, this_speaker->data_buffer_ + i * single_dma_buffer_input_size,
-                            bytes_to_write, &bytes_written, pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS * 5));
-#endif
 
           uint32_t write_timestamp = micros();
 
@@ -398,12 +369,8 @@ void I2SAudioSpeaker::speaker_task(void *params) {
     }
 
     xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::STATE_STOPPING);
-#ifdef USE_I2S_LEGACY
+
     i2s_driver_uninstall(this_speaker->parent_->get_port());
-#else
-    i2s_channel_disable(this_speaker->tx_handle_);
-    i2s_del_channel(this_speaker->tx_handle_);
-#endif
 
     this_speaker->parent_->unlock();
   }
@@ -495,21 +462,12 @@ esp_err_t I2SAudioSpeaker::allocate_buffers_(size_t data_buffer_size, size_t rin
 }
 
 esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info) {
-#ifdef USE_I2S_LEGACY
   if ((this->i2s_mode_ & I2S_MODE_SLAVE) && (this->sample_rate_ != audio_stream_info.get_sample_rate())) {  // NOLINT
-#else
-  if ((this->i2s_role_ & I2S_ROLE_SLAVE) && (this->sample_rate_ != audio_stream_info.get_sample_rate())) {  // NOLINT
-#endif
     // Can't reconfigure I2S bus, so the sample rate must match the configured value
     return ESP_ERR_NOT_SUPPORTED;
   }
 
-#ifdef USE_I2S_LEGACY
   if ((i2s_bits_per_sample_t) audio_stream_info.get_bits_per_sample() > this->bits_per_sample_) {
-#else
-  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO &&
-      (i2s_slot_bit_width_t) audio_stream_info.get_bits_per_sample() > this->slot_bit_width_) {
-#endif
     // Currently can't handle the case when the incoming audio has more bits per sample than the configured value
     return ESP_ERR_NOT_SUPPORTED;
   }
@@ -518,9 +476,6 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_strea
     return ESP_ERR_INVALID_STATE;
   }
 
-  uint32_t dma_buffer_length = audio_stream_info.ms_to_frames(DMA_BUFFER_DURATION_MS);
-
-#ifdef USE_I2S_LEGACY
   i2s_channel_fmt_t channel = this->channel_;
 
   if (audio_stream_info.get_channels() == 1) {
@@ -533,6 +488,8 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_strea
     channel = I2S_CHANNEL_FMT_RIGHT_LEFT;
   }
 
+  int dma_buffer_length = audio_stream_info.ms_to_frames(DMA_BUFFER_DURATION_MS);
+
   i2s_driver_config_t config = {
     .mode = (i2s_mode_t) (this->i2s_mode_ | I2S_MODE_TX),
     .sample_rate = audio_stream_info.get_sample_rate(),
@@ -541,7 +498,7 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_strea
     .communication_format = this->i2s_comm_fmt_,
     .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
     .dma_buf_count = DMA_BUFFERS_COUNT,
-    .dma_buf_len = (int) dma_buffer_length,
+    .dma_buf_len = dma_buffer_length,
     .use_apll = this->use_apll_,
     .tx_desc_auto_clear = true,
     .fixed_mclk = I2S_PIN_NO_CHANGE,
@@ -588,89 +545,6 @@ esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_strea
     i2s_driver_uninstall(this->parent_->get_port());
     this->parent_->unlock();
   }
-#else
-  i2s_chan_config_t chan_cfg = {
-      .id = this->parent_->get_port(),
-      .role = this->i2s_role_,
-      .dma_desc_num = DMA_BUFFERS_COUNT,
-      .dma_frame_num = dma_buffer_length,
-      .auto_clear = true,
-  };
-  /* Allocate a new TX channel and get the handle of this channel */
-  esp_err_t err = i2s_new_channel(&chan_cfg, &this->tx_handle_, NULL);
-  if (err != ESP_OK) {
-    this->parent_->unlock();
-    return err;
-  }
-
-  i2s_clock_src_t clk_src = I2S_CLK_SRC_DEFAULT;
-#ifdef I2S_CLK_SRC_APLL
-  if (this->use_apll_) {
-    clk_src = I2S_CLK_SRC_APLL;
-  }
-#endif
-  i2s_std_gpio_config_t pin_config = this->parent_->get_pin_config();
-
-  i2s_std_clk_config_t clk_cfg = {
-      .sample_rate_hz = audio_stream_info.get_sample_rate(),
-      .clk_src = clk_src,
-      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
-  };
-
-  i2s_slot_mode_t slot_mode = this->slot_mode_;
-  i2s_std_slot_mask_t slot_mask = this->std_slot_mask_;
-  if (audio_stream_info.get_channels() == 1) {
-    slot_mode = I2S_SLOT_MODE_MONO;
-  } else if (audio_stream_info.get_channels() == 2) {
-    slot_mode = I2S_SLOT_MODE_STEREO;
-    slot_mask = I2S_STD_SLOT_BOTH;
-  }
-
-  i2s_std_slot_config_t std_slot_cfg;
-  if (this->i2s_comm_fmt_ == "std") {
-    std_slot_cfg =
-        I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
-  } else if (this->i2s_comm_fmt_ == "pcm") {
-    std_slot_cfg =
-        I2S_STD_PCM_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
-  } else {
-    std_slot_cfg =
-        I2S_STD_MSB_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
-  }
-  std_slot_cfg.slot_bit_width = this->slot_bit_width_;
-  std_slot_cfg.slot_mask = slot_mask;
-
-  pin_config.dout = this->dout_pin_;
-
-  i2s_std_config_t std_cfg = {
-      .clk_cfg = clk_cfg,
-      .slot_cfg = std_slot_cfg,
-      .gpio_cfg = pin_config,
-  };
-  /* Initialize the channel */
-  err = i2s_channel_init_std_mode(this->tx_handle_, &std_cfg);
-
-  if (err != ESP_OK) {
-    i2s_del_channel(this->tx_handle_);
-    this->parent_->unlock();
-    return err;
-  }
-  if (this->i2s_event_queue_ == nullptr) {
-    this->i2s_event_queue_ = xQueueCreate(1, sizeof(bool));
-  }
-  const i2s_event_callbacks_t callbacks = {
-      .on_send_q_ovf = i2s_overflow_cb,
-  };
-
-  i2s_channel_register_event_callback(this->tx_handle_, &callbacks, this);
-
-  /* Before reading data, start the TX channel first */
-  i2s_channel_enable(this->tx_handle_);
-  if (err != ESP_OK) {
-    i2s_del_channel(this->tx_handle_);
-    this->parent_->unlock();
-  }
-#endif
 
   return err;
 }
@@ -690,15 +564,6 @@ void I2SAudioSpeaker::delete_task_(size_t buffer_size) {
   vTaskDelete(nullptr);
 }
 
-#ifndef USE_I2S_LEGACY
-bool IRAM_ATTR I2SAudioSpeaker::i2s_overflow_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx) {
-  I2SAudioSpeaker *this_speaker = (I2SAudioSpeaker *) user_ctx;
-  bool overflow = true;
-  xQueueOverwrite(this_speaker->i2s_event_queue_, &overflow);
-  return false;
-}
-#endif
-
 }  // namespace i2s_audio
 }  // namespace esphome
 

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -4,6 +4,8 @@
 
 #include "../i2s_audio.h"
 
+#include <driver/i2s.h>
+
 #include <freertos/event_groups.h>
 #include <freertos/queue.h>
 #include <freertos/FreeRTOS.h>
@@ -28,16 +30,11 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
 
   void set_buffer_duration(uint32_t buffer_duration_ms) { this->buffer_duration_ms_ = buffer_duration_ms; }
   void set_timeout(uint32_t ms) { this->timeout_ = ms; }
-#ifdef USE_I2S_LEGACY
+  void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
 #if SOC_I2S_SUPPORTS_DAC
   void set_internal_dac_mode(i2s_dac_mode_t mode) { this->internal_dac_mode_ = mode; }
 #endif
-  void set_dout_pin(uint8_t pin) { this->dout_pin_ = pin; }
   void set_i2s_comm_fmt(i2s_comm_format_t mode) { this->i2s_comm_fmt_ = mode; }
-#else
-  void set_dout_pin(uint8_t pin) { this->dout_pin_ = (gpio_num_t) pin; }
-  void set_i2s_comm_fmt(std::string mode) { this->i2s_comm_fmt_ = std::move(mode); }
-#endif
 
   void start() override;
   void stop() override;
@@ -89,10 +86,6 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   /// @return True if an ERR_ESP bit is set and false if err == ESP_OK
   bool send_esp_err_to_event_group_(esp_err_t err);
 
-#ifndef USE_I2S_LEGACY
-  static bool i2s_overflow_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx);
-#endif
-
   /// @brief Allocates the data buffer and ring buffer
   /// @param data_buffer_size Number of bytes to allocate for the data buffer.
   /// @param ring_buffer_size Number of bytes to allocate for the ring buffer.
@@ -128,6 +121,7 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
   uint32_t buffer_duration_ms_;
 
   optional<uint32_t> timeout_;
+  uint8_t dout_pin_;
 
   bool task_created_{false};
   bool pause_state_{false};
@@ -136,17 +130,10 @@ class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Comp
 
   size_t bytes_written_{0};
 
-#ifdef USE_I2S_LEGACY
 #if SOC_I2S_SUPPORTS_DAC
   i2s_dac_mode_t internal_dac_mode_{I2S_DAC_CHANNEL_DISABLE};
 #endif
-  uint8_t dout_pin_;
   i2s_comm_format_t i2s_comm_fmt_;
-#else
-  gpio_num_t dout_pin_;
-  std::string i2s_comm_fmt_;
-  i2s_chan_handle_t tx_handle_;
-#endif
 
   uint32_t accumulated_frames_written_{0};
 };

esphome/components/image/__init__.py

@@ -291,8 +291,6 @@ SOURCE_WEB = "web"
 
 Image_ = image_ns.class_("Image")
 
-INSTANCE_TYPE = Image_
-
 
 def compute_local_image_path(value) -> Path:
     url = value[CONF_URL] if isinstance(value, dict) else value

esphome/components/internal_temperature/internal_temperature.cpp

@@ -9,7 +9,7 @@ uint8_t temprature_sens_read();
 }
 #elif defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || \
     defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || \
-    defined(USE_ESP32_VARIANT_ESP32C2) || defined(USE_ESP32_VARIANT_ESP32P4)
+    defined(USE_ESP32_VARIANT_ESP32C2)
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
 #include "driver/temp_sensor.h"
 #else
@@ -33,8 +33,7 @@ static const char *const TAG = "internal_temperature";
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)) && \
     (defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32S2) || \
-     defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32C2) || \
-     defined(USE_ESP32_VARIANT_ESP32P4))
+     defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32C2))
 static temperature_sensor_handle_t tsensNew = NULL;
 #endif  // ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0) && USE_ESP32_VARIANT
 #endif  // USE_ESP32
@@ -50,7 +49,7 @@ void InternalTemperatureSensor::update() {
   success = (raw != 128);
 #elif defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || \
     defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || \
-    defined(USE_ESP32_VARIANT_ESP32C2) || defined(USE_ESP32_VARIANT_ESP32P4)
+    defined(USE_ESP32_VARIANT_ESP32C2)
 #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
   temp_sensor_config_t tsens = TSENS_CONFIG_DEFAULT();
   temp_sensor_set_config(tsens);
@@ -101,8 +100,7 @@ void InternalTemperatureSensor::setup() {
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)) && \
     (defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32S2) || \
-     defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32C2) || \
-     defined(USE_ESP32_VARIANT_ESP32P4))
+     defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32C2))
   ESP_LOGCONFIG(TAG, "Setting up temperature sensor...");
 
   temperature_sensor_config_t tsens_config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(-10, 80);

esphome/components/lvgl/__init__.py

@@ -2,7 +2,6 @@ import logging
 
 from esphome.automation import build_automation, register_action, validate_automation
 import esphome.codegen as cg
-from esphome.components.const import CONF_DRAW_ROUNDING
 from esphome.components.display import Display
 import esphome.config_validation as cv
 from esphome.const import (
@@ -25,7 +24,7 @@ from esphome.helpers import write_file_if_changed
 
 from . import defines as df, helpers, lv_validation as lvalid
 from .automation import disp_update, focused_widgets, update_to_code
-from .defines import add_define
+from .defines import CONF_DRAW_ROUNDING, add_define
 from .encoders import (
     ENCODERS_CONFIG,
     encoders_to_code,
@@ -324,7 +323,7 @@ async def to_code(configs):
             displays,
             frac,
             config[df.CONF_FULL_REFRESH],
-            config[CONF_DRAW_ROUNDING],
+            config[df.CONF_DRAW_ROUNDING],
             config[df.CONF_RESUME_ON_INPUT],
         )
         await cg.register_component(lv_component, config)
@@ -414,7 +413,7 @@ LVGL_SCHEMA = cv.All(
                     df.CONF_DEFAULT_FONT, default="montserrat_14"
                 ): lvalid.lv_font,
                 cv.Optional(df.CONF_FULL_REFRESH, default=False): cv.boolean,
-                cv.Optional(CONF_DRAW_ROUNDING, default=2): cv.positive_int,
+                cv.Optional(df.CONF_DRAW_ROUNDING, default=2): cv.positive_int,
                 cv.Optional(CONF_BUFFER_SIZE, default="100%"): cv.percentage,
                 cv.Optional(df.CONF_LOG_LEVEL, default="WARN"): cv.one_of(
                     *df.LV_LOG_LEVELS, upper=True

esphome/components/lvgl/defines.py

@@ -424,6 +424,7 @@ CONF_DEFAULT_FONT = "default_font"
 CONF_DEFAULT_GROUP = "default_group"
 CONF_DIR = "dir"
 CONF_DISPLAYS = "displays"
+CONF_DRAW_ROUNDING = "draw_rounding"
 CONF_EDITING = "editing"
 CONF_ENCODERS = "encoders"
 CONF_END_ANGLE = "end_angle"

esphome/components/lvgl/lv_validation.py

@@ -16,7 +16,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj
-from esphome.cpp_types import ESPTime, uint32
+from esphome.cpp_types import ESPTime, int32, uint32
 from esphome.helpers import cpp_string_escape
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 
@@ -263,6 +263,15 @@ def pixels_validator(value):
 pixels = LValidator(pixels_validator, uint32, retmapper=literal)
 
 
+def padding_validator(value):
+    if isinstance(value, str) and value.lower().endswith("px"):
+        value = value[:-2]
+    return cv.int_(value)
+
+
+padding = LValidator(padding_validator, int32, retmapper=literal)
+
+
 def zoom_validator(value):
     value = cv.float_range(0.1, 10.0)(value)
     return value

esphome/components/lvgl/lvgl_esphome.cpp

@@ -434,11 +434,7 @@ void LvglComponent::setup() {
   auto height = display->get_height();
   size_t buffer_pixels = width * height / this->buffer_frac_;
   auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
-  void *buffer = nullptr;
-  if (this->buffer_frac_ >= 4)
-    buffer = malloc(buf_bytes);  // NOLINT
-  if (buffer == nullptr)
-    buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
+  auto *buffer = lv_custom_mem_alloc(buf_bytes);  // NOLINT
   if (buffer == nullptr) {
     this->mark_failed();
     this->status_set_error("Memory allocation failure");

esphome/components/lvgl/schemas.py

@@ -156,13 +156,13 @@ STYLE_PROPS = {
     "opa_layered": lvalid.opacity,
     "outline_color": lvalid.lv_color,
     "outline_opa": lvalid.opacity,
-    "outline_pad": lvalid.pixels,
+    "outline_pad": lvalid.padding,
     "outline_width": lvalid.pixels,
-    "pad_all": lvalid.pixels,
-    "pad_bottom": lvalid.pixels,
-    "pad_left": lvalid.pixels,
-    "pad_right": lvalid.pixels,
-    "pad_top": lvalid.pixels,
+    "pad_all": lvalid.padding,
+    "pad_bottom": lvalid.padding,
+    "pad_left": lvalid.padding,
+    "pad_right": lvalid.padding,
+    "pad_top": lvalid.padding,
     "shadow_color": lvalid.lv_color,
     "shadow_ofs_x": lvalid.lv_int,
     "shadow_ofs_y": lvalid.lv_int,
@@ -226,8 +226,8 @@ FULL_STYLE_SCHEMA = STYLE_SCHEMA.extend(
     {
         cv.Optional(df.CONF_GRID_CELL_X_ALIGN): grid_alignments,
         cv.Optional(df.CONF_GRID_CELL_Y_ALIGN): grid_alignments,
-        cv.Optional(df.CONF_PAD_ROW): lvalid.pixels,
-        cv.Optional(df.CONF_PAD_COLUMN): lvalid.pixels,
+        cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
+        cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
     }
 )
 
@@ -370,8 +370,8 @@ LAYOUT_SCHEMA = {
                 cv.Required(df.CONF_GRID_COLUMNS): [grid_spec],
                 cv.Optional(df.CONF_GRID_COLUMN_ALIGN): grid_alignments,
                 cv.Optional(df.CONF_GRID_ROW_ALIGN): grid_alignments,
-                cv.Optional(df.CONF_PAD_ROW): lvalid.pixels,
-                cv.Optional(df.CONF_PAD_COLUMN): lvalid.pixels,
+                cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
+                cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
             },
             df.TYPE_FLEX: {
                 cv.Optional(
@@ -380,8 +380,8 @@ LAYOUT_SCHEMA = {
                 cv.Optional(df.CONF_FLEX_ALIGN_MAIN, default="start"): flex_alignments,
                 cv.Optional(df.CONF_FLEX_ALIGN_CROSS, default="start"): flex_alignments,
                 cv.Optional(df.CONF_FLEX_ALIGN_TRACK, default="start"): flex_alignments,
-                cv.Optional(df.CONF_PAD_ROW): lvalid.pixels,
-                cv.Optional(df.CONF_PAD_COLUMN): lvalid.pixels,
+                cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
+                cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
             },
         },
         lower=True,
@@ -427,8 +427,8 @@ ALL_STYLES = {
     **STYLE_PROPS,
     **GRID_CELL_SCHEMA,
     **FLEX_OBJ_SCHEMA,
-    cv.Optional(df.CONF_PAD_ROW): lvalid.pixels,
-    cv.Optional(df.CONF_PAD_COLUMN): lvalid.pixels,
+    cv.Optional(df.CONF_PAD_ROW): lvalid.padding,
+    cv.Optional(df.CONF_PAD_COLUMN): lvalid.padding,
 }
 
 

esphome/components/lvgl/widgets/buttonmatrix.py

@@ -19,7 +19,7 @@ from ..defines import (
     CONF_SELECTED,
 )
 from ..helpers import lvgl_components_required
-from ..lv_validation import key_code, lv_bool, pixels
+from ..lv_validation import key_code, lv_bool, padding
 from ..lvcode import lv, lv_add, lv_expr
 from ..schemas import automation_schema
 from ..types import (
@@ -59,8 +59,8 @@ BUTTONMATRIX_BUTTON_SCHEMA = cv.Schema(
 BUTTONMATRIX_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_ONE_CHECKED, default=False): lv_bool,
-        cv.Optional(CONF_PAD_ROW): pixels,
-        cv.Optional(CONF_PAD_COLUMN): pixels,
+        cv.Optional(CONF_PAD_ROW): padding,
+        cv.Optional(CONF_PAD_COLUMN): padding,
         cv.GenerateID(CONF_BUTTON_TEXT_LIST_ID): cv.declare_id(char_ptr),
         cv.Required(CONF_ROWS): cv.ensure_list(
             cv.Schema(

esphome/components/lvgl/widgets/checkbox.py

@@ -2,7 +2,7 @@ from esphome.config_validation import Optional
 from esphome.const import CONF_TEXT
 
 from ..defines import CONF_INDICATOR, CONF_MAIN, CONF_PAD_COLUMN
-from ..lv_validation import lv_text, pixels
+from ..lv_validation import lv_text, padding
 from ..lvcode import lv
 from ..schemas import TEXT_SCHEMA
 from ..types import LvBoolean
@@ -19,7 +19,7 @@ class CheckboxType(WidgetType):
             (CONF_MAIN, CONF_INDICATOR),
             TEXT_SCHEMA.extend(
                 {
-                    Optional(CONF_PAD_COLUMN): pixels,
+                    Optional(CONF_PAD_COLUMN): padding,
                 }
             ),
         )

esphome/components/lvgl/widgets/img.py

@@ -10,7 +10,7 @@ from ..defines import (
     CONF_ZOOM,
     LvConstant,
 )
-from ..lv_validation import angle, lv_bool, lv_image, size, zoom
+from ..lv_validation import lv_angle, lv_bool, lv_image, size, zoom
 from ..lvcode import lv
 from ..types import lv_img_t
 from . import Widget, WidgetType
@@ -22,7 +22,7 @@ BASE_IMG_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_PIVOT_X): size,
         cv.Optional(CONF_PIVOT_Y): size,
-        cv.Optional(CONF_ANGLE): angle,
+        cv.Optional(CONF_ANGLE): lv_angle,
         cv.Optional(CONF_ZOOM): zoom,
         cv.Optional(CONF_OFFSET_X): size,
         cv.Optional(CONF_OFFSET_Y): size,
@@ -66,17 +66,19 @@ class ImgType(WidgetType):
         if (pivot_x := config.get(CONF_PIVOT_X)) and (
             pivot_y := config.get(CONF_PIVOT_Y)
         ):
-            lv.img_set_pivot(w.obj, pivot_x, pivot_y)
+            lv.img_set_pivot(
+                w.obj, await size.process(pivot_x), await size.process(pivot_y)
+            )
         if (cf_angle := config.get(CONF_ANGLE)) is not None:
-            lv.img_set_angle(w.obj, cf_angle)
+            lv.img_set_angle(w.obj, await lv_angle.process(cf_angle))
         if (img_zoom := config.get(CONF_ZOOM)) is not None:
-            lv.img_set_zoom(w.obj, img_zoom)
+            lv.img_set_zoom(w.obj, await zoom.process(img_zoom))
         if (offset := config.get(CONF_OFFSET_X)) is not None:
-            lv.img_set_offset_x(w.obj, offset)
+            lv.img_set_offset_x(w.obj, await size.process(offset))
         if (offset := config.get(CONF_OFFSET_Y)) is not None:
-            lv.img_set_offset_y(w.obj, offset)
+            lv.img_set_offset_y(w.obj, await size.process(offset))
         if CONF_ANTIALIAS in config:
-            lv.img_set_antialias(w.obj, config[CONF_ANTIALIAS])
+            lv.img_set_antialias(w.obj, await lv_bool.process(config[CONF_ANTIALIAS]))
         if mode := config.get(CONF_MODE):
             await w.set_property("size_mode", mode)
 

esphome/components/mapping/__init__.py

@@ -1,134 +0,0 @@
-import difflib
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_FROM, CONF_ID, CONF_TO
-from esphome.core import CORE
-from esphome.cpp_generator import MockObj, VariableDeclarationExpression, add_global
-from esphome.loader import get_component
-
-CODEOWNERS = ["@clydebarrow"]
-MULTI_CONF = True
-
-map_ = cg.std_ns.class_("map")
-
-CONF_ENTRIES = "entries"
-CONF_CLASS = "class"
-
-
-class IndexType:
-    """
-    Represents a type of index in a map.
-    """
-
-    def __init__(self, validator, data_type, conversion):
-        self.validator = validator
-        self.data_type = data_type
-        self.conversion = conversion
-
-
-INDEX_TYPES = {
-    "int": IndexType(cv.int_, cg.int_, int),
-    "string": IndexType(cv.string, cg.std_string, str),
-}
-
-
-def to_schema(value):
-    """
-    Generate a schema for the 'to' field of a map. This can be either one of the index types or a class name.
-    :param value:
-    :return:
-    """
-    return cv.Any(
-        cv.one_of(*INDEX_TYPES, lower=True),
-        cv.one_of(*CORE.id_classes.keys()),
-    )(value)
-
-
-BASE_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.declare_id(map_),
-        cv.Required(CONF_FROM): cv.one_of(*INDEX_TYPES, lower=True),
-        cv.Required(CONF_TO): cv.string,
-    },
-    extra=cv.ALLOW_EXTRA,
-)
-
-
-def get_object_type(to_):
-    """
-    Get the object type from a string. Possible formats:
-       xxx The name of a component which defines INSTANCE_TYPE
-       esphome::xxx::yyy A C++ class name defined in a component
-       xxx::yyy A C++ class name defined in a component
-       yyy A C++ class name defined in the core
-    """
-
-    if cls := CORE.id_classes.get(to_):
-        return cls
-    if cls := CORE.id_classes.get(to_.removeprefix("esphome::")):
-        return cls
-    # get_component will throw a wobbly if we don't check this first.
-    if "." in to_:
-        return None
-    if component := get_component(to_):
-        return component.instance_type
-    return None
-
-
-def map_schema(config):
-    config = BASE_SCHEMA(config)
-    if CONF_ENTRIES not in config or not isinstance(config[CONF_ENTRIES], dict):
-        raise cv.Invalid("an entries list is required for a map")
-    entries = config[CONF_ENTRIES]
-    if len(entries) == 0:
-        raise cv.Invalid("Map must have at least one entry")
-    to_ = config[CONF_TO]
-    if to_ in INDEX_TYPES:
-        value_type = INDEX_TYPES[to_].validator
-    else:
-        value_type = get_object_type(to_)
-        if value_type is None:
-            matches = difflib.get_close_matches(to_, CORE.id_classes)
-            raise cv.Invalid(
-                f"No known mappable class name matches '{to_}'; did you mean one of {', '.join(matches)}?"
-            )
-        value_type = cv.use_id(value_type)
-    config[CONF_ENTRIES] = {k: value_type(v) for k, v in entries.items()}
-    return config
-
-
-CONFIG_SCHEMA = map_schema
-
-
-async def to_code(config):
-    entries = config[CONF_ENTRIES]
-    from_ = config[CONF_FROM]
-    to_ = config[CONF_TO]
-    index_conversion = INDEX_TYPES[from_].conversion
-    index_type = INDEX_TYPES[from_].data_type
-    if to_ in INDEX_TYPES:
-        value_conversion = INDEX_TYPES[to_].conversion
-        value_type = INDEX_TYPES[to_].data_type
-        entries = {
-            index_conversion(key): value_conversion(value)
-            for key, value in entries.items()
-        }
-    else:
-        entries = {
-            index_conversion(key): await cg.get_variable(value)
-            for key, value in entries.items()
-        }
-        value_type = get_object_type(to_)
-        if list(entries.values())[0].op != ".":
-            value_type = value_type.operator("ptr")
-    varid = config[CONF_ID]
-    varid.type = map_.template(index_type, value_type)
-    var = MockObj(varid, ".")
-    decl = VariableDeclarationExpression(varid.type, "", varid)
-    add_global(decl)
-    CORE.register_variable(varid, var)
-
-    for key, value in entries.items():
-        cg.add(var.insert((key, value)))
-    return var

esphome/components/mdns/mdns_component.cpp

@@ -1,9 +1,9 @@
 #include "esphome/core/defines.h"
 #ifdef USE_MDNS
+#include "mdns_component.h"
+#include "esphome/core/version.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
-#include "esphome/core/version.h"
-#include "mdns_component.h"
 
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
@@ -62,11 +62,7 @@ void MDNSComponent::compile_records_() {
 #endif
 
 #ifdef USE_API_NOISE
-    if (api::global_api_server->get_noise_ctx()->has_psk()) {
-      service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
-    } else {
-      service.txt_records.push_back({"api_encryption_supported", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
-    }
+    service.txt_records.push_back({"api_encryption", "Noise_NNpsk0_25519_ChaChaPoly_SHA256"});
 #endif
 
 #ifdef ESPHOME_PROJECT_NAME

esphome/components/media_player/__init__.py

@@ -134,11 +134,13 @@ MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
 )
 
 
-MEDIA_PLAYER_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.use_id(MediaPlayer),
-        cv.Optional(CONF_ANNOUNCEMENT, default=False): cv.templatable(cv.boolean),
-    }
+MEDIA_PLAYER_ACTION_SCHEMA = automation.maybe_simple_id(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(MediaPlayer),
+            cv.Optional(CONF_ANNOUNCEMENT, default=False): cv.templatable(cv.boolean),
+        }
+    )
 )
 
 MEDIA_PLAYER_CONDITION_SCHEMA = automation.maybe_simple_id(

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -61,29 +61,6 @@ void MicroWakeWord::dump_config() {
 void MicroWakeWord::setup() {
   ESP_LOGCONFIG(TAG, "Setting up microWakeWord...");
 
-  this->microphone_->add_data_callback([this](const std::vector<int16_t> &data) {
-    if (this->state_ != State::DETECTING_WAKE_WORD) {
-      return;
-    }
-    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_;
-    if (this->ring_buffer_.use_count() == 2) {
-      // mWW still owns the ring buffer and temp_ring_buffer does as well, proceed to copy audio into ring buffer
-
-      size_t bytes_free = temp_ring_buffer->free();
-
-      if (bytes_free < data.size() * sizeof(int16_t)) {
-        ESP_LOGW(
-            TAG,
-            "Not enough free bytes in ring buffer to store incoming audio data (free bytes=%d, incoming bytes=%d). "
-            "Resetting the ring buffer. Wake word detection accuracy will be reduced.",
-            bytes_free, data.size());
-
-        temp_ring_buffer->reset();
-      }
-      temp_ring_buffer->write((void *) data.data(), data.size() * sizeof(int16_t));
-    }
-  });
-
   if (!this->register_streaming_ops_(this->streaming_op_resolver_)) {
     this->mark_failed();
     return;
@@ -130,6 +107,7 @@ void MicroWakeWord::loop() {
       ESP_LOGD(TAG, "Starting Microphone");
       this->microphone_->start();
       this->set_state_(State::STARTING_MICROPHONE);
+      this->high_freq_.start();
       break;
     case State::STARTING_MICROPHONE:
       if (this->microphone_->is_running()) {
@@ -137,19 +115,21 @@ void MicroWakeWord::loop() {
       }
       break;
     case State::DETECTING_WAKE_WORD:
-      while (this->has_enough_samples_()) {
-        this->update_model_probabilities_();
-        if (this->detect_wake_words_()) {
-          ESP_LOGD(TAG, "Wake Word '%s' Detected", (this->detected_wake_word_).c_str());
-          this->detected_ = true;
-          this->set_state_(State::STOP_MICROPHONE);
-        }
+      while (!this->has_enough_samples_()) {
+        this->read_microphone_();
+      }
+      this->update_model_probabilities_();
+      if (this->detect_wake_words_()) {
+        ESP_LOGD(TAG, "Wake Word '%s' Detected", (this->detected_wake_word_).c_str());
+        this->detected_ = true;
+        this->set_state_(State::STOP_MICROPHONE);
       }
       break;
     case State::STOP_MICROPHONE:
       ESP_LOGD(TAG, "Stopping Microphone");
       this->microphone_->stop();
       this->set_state_(State::STOPPING_MICROPHONE);
+      this->high_freq_.stop();
       this->unload_models_();
       this->deallocate_buffers_();
       break;
@@ -177,11 +157,6 @@ void MicroWakeWord::start() {
     return;
   }
 
-  if (this->state_ != State::IDLE) {
-    ESP_LOGW(TAG, "Wake word is already running");
-    return;
-  }
-
   if (!this->load_models_() || !this->allocate_buffers_()) {
     ESP_LOGE(TAG, "Failed to load the wake word model(s) or allocate buffers");
     this->status_set_error();
@@ -194,6 +169,11 @@ void MicroWakeWord::start() {
     return;
   }
 
+  if (this->state_ != State::IDLE) {
+    ESP_LOGW(TAG, "Wake word is already running");
+    return;
+  }
+
   this->reset_states_();
   this->set_state_(State::START_MICROPHONE);
 }
@@ -216,6 +196,26 @@ void MicroWakeWord::set_state_(State state) {
   this->state_ = state;
 }
 
+size_t MicroWakeWord::read_microphone_() {
+  size_t bytes_read = this->microphone_->read(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
+  if (bytes_read == 0) {
+    return 0;
+  }
+
+  size_t bytes_free = this->ring_buffer_->free();
+
+  if (bytes_free < bytes_read) {
+    ESP_LOGW(TAG,
+             "Not enough free bytes in ring buffer to store incoming audio data (free bytes=%d, incoming bytes=%d). "
+             "Resetting the ring buffer. Wake word detection accuracy will be reduced.",
+             bytes_free, bytes_read);
+
+    this->ring_buffer_->reset();
+  }
+
+  return this->ring_buffer_->write((void *) this->input_buffer_, bytes_read);
+}
+
 bool MicroWakeWord::allocate_buffers_() {
   ExternalRAMAllocator<int16_t> audio_samples_allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
 
@@ -235,9 +235,9 @@ bool MicroWakeWord::allocate_buffers_() {
     }
   }
 
-  if (this->ring_buffer_.use_count() == 0) {
+  if (this->ring_buffer_ == nullptr) {
     this->ring_buffer_ = RingBuffer::create(BUFFER_SIZE * sizeof(int16_t));
-    if (this->ring_buffer_.use_count() == 0) {
+    if (this->ring_buffer_ == nullptr) {
       ESP_LOGE(TAG, "Could not allocate ring buffer");
       return false;
     }
@@ -248,17 +248,10 @@ bool MicroWakeWord::allocate_buffers_() {
 
 void MicroWakeWord::deallocate_buffers_() {
   ExternalRAMAllocator<int16_t> audio_samples_allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
-  if (this->input_buffer_ != nullptr) {
-    audio_samples_allocator.deallocate(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
-    this->input_buffer_ = nullptr;
-  }
-
-  if (this->preprocessor_audio_buffer_ != nullptr) {
-    audio_samples_allocator.deallocate(this->preprocessor_audio_buffer_, this->new_samples_to_get_());
-    this->preprocessor_audio_buffer_ = nullptr;
-  }
-
-  this->ring_buffer_.reset();
+  audio_samples_allocator.deallocate(this->input_buffer_, INPUT_BUFFER_SIZE * sizeof(int16_t));
+  this->input_buffer_ = nullptr;
+  audio_samples_allocator.deallocate(this->preprocessor_audio_buffer_, this->new_samples_to_get_());
+  this->preprocessor_audio_buffer_ = nullptr;
 }
 
 bool MicroWakeWord::load_models_() {

esphome/components/micro_wake_word/micro_wake_word.h

@@ -62,8 +62,9 @@ class MicroWakeWord : public Component {
   microphone::Microphone *microphone_{nullptr};
   Trigger<std::string> *wake_word_detected_trigger_ = new Trigger<std::string>();
   State state_{State::IDLE};
+  HighFrequencyLoopRequester high_freq_;
 
-  std::shared_ptr<RingBuffer> ring_buffer_;
+  std::unique_ptr<RingBuffer> ring_buffer_;
 
   std::vector<WakeWordModel> wake_word_models_;
 
@@ -97,6 +98,15 @@ class MicroWakeWord : public Component {
   /// @return True if enough samples, false otherwise.
   bool has_enough_samples_();
 
+  /** Reads audio from microphone into the ring buffer
+   *
+   * Audio data (16000 kHz with int16 samples) is read into the input_buffer_.
+   * Verifies the ring buffer has enough space for all audio data. If not, it logs
+   * a warning and resets the ring buffer entirely.
+   * @return Number of bytes written to the ring buffer
+   */
+  size_t read_microphone_();
+
   /// @brief Allocates memory for input_buffer_, preprocessor_audio_buffer_, and ring_buffer_
   /// @return True if successful, false otherwise
   bool allocate_buffers_();

esphome/components/mqtt/mqtt_client.cpp

@@ -138,11 +138,7 @@ void MQTTClientComponent::send_device_info_() {
 #endif
 
 #ifdef USE_API_NOISE
-        if (api::global_api_server->get_noise_ctx()->has_psk()) {
-          root["api_encryption"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
-        } else {
-          root["api_encryption_supported"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
-        }
+        root["api_encryption"] = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
 #endif
       },
       2, this->discovery_info_.retain);

esphome/components/network/__init__.py

@@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.Schema(
                     esp32_arduino=cv.Version(0, 0, 0),
                     esp8266_arduino=cv.Version(0, 0, 0),
                     rp2040_arduino=cv.Version(0, 0, 0),
-                    bk72xx_arduino=cv.Version(1, 7, 0),
+                    bk72xx_libretiny=cv.Version(1, 7, 0),
                 ),
                 cv.boolean_false,
             ),

esphome/components/pm2005/__init__.py

@@ -1 +0,0 @@
-"""PM2005/2105 component for ESPHome."""

esphome/components/pm2005/pm2005.cpp

@@ -1,123 +0,0 @@
-#include "esphome/core/log.h"
-#include "pm2005.h"
-
-namespace esphome {
-namespace pm2005 {
-
-static const char *const TAG = "pm2005";
-
-// Converts a sensor situation to a human readable string
-static const LogString *pm2005_get_situation_string(int status) {
-  switch (status) {
-    case 1:
-      return LOG_STR("Close");
-    case 2:
-      return LOG_STR("Malfunction");
-    case 3:
-      return LOG_STR("Under detecting");
-    case 0x80:
-      return LOG_STR("Detecting completed");
-    default:
-      return LOG_STR("Invalid");
-  }
-}
-
-// Converts a sensor measuring mode to a human readable string
-static const LogString *pm2005_get_measuring_mode_string(int status) {
-  switch (status) {
-    case 2:
-      return LOG_STR("Single");
-    case 3:
-      return LOG_STR("Continuous");
-    case 5:
-      return LOG_STR("Dynamic");
-    default:
-      return LOG_STR("Timing");
-  }
-}
-
-static inline uint16_t get_sensor_value(const uint8_t *data, uint8_t i) { return data[i] * 0x100 + data[i + 1]; }
-
-void PM2005Component::setup() {
-  if (this->sensor_type_ == PM2005) {
-    ESP_LOGCONFIG(TAG, "Setting up PM2005...");
-
-    this->situation_value_index_ = 3;
-    this->pm_1_0_value_index_ = 4;
-    this->pm_2_5_value_index_ = 6;
-    this->pm_10_0_value_index_ = 8;
-    this->measuring_value_index_ = 10;
-  } else {
-    ESP_LOGCONFIG(TAG, "Setting up PM2105...");
-
-    this->situation_value_index_ = 2;
-    this->pm_1_0_value_index_ = 3;
-    this->pm_2_5_value_index_ = 5;
-    this->pm_10_0_value_index_ = 7;
-    this->measuring_value_index_ = 9;
-  }
-
-  if (this->read(this->data_buffer_, 12) != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, "Communication failed!");
-    this->mark_failed();
-    return;
-  }
-}
-
-void PM2005Component::update() {
-  if (this->read(this->data_buffer_, 12) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Read result failed.");
-    this->status_set_warning();
-    return;
-  }
-
-  if (this->sensor_situation_ == this->data_buffer_[this->situation_value_index_]) {
-    return;
-  }
-
-  this->sensor_situation_ = this->data_buffer_[this->situation_value_index_];
-  ESP_LOGD(TAG, "Sensor situation: %s.", LOG_STR_ARG(pm2005_get_situation_string(this->sensor_situation_)));
-  if (this->sensor_situation_ == 2) {
-    this->status_set_warning();
-    return;
-  }
-  if (this->sensor_situation_ != 0x80) {
-    return;
-  }
-
-  uint16_t pm1 = get_sensor_value(this->data_buffer_, this->pm_1_0_value_index_);
-  uint16_t pm25 = get_sensor_value(this->data_buffer_, this->pm_2_5_value_index_);
-  uint16_t pm10 = get_sensor_value(this->data_buffer_, this->pm_10_0_value_index_);
-  uint16_t sensor_measuring_mode = get_sensor_value(this->data_buffer_, this->measuring_value_index_);
-  ESP_LOGD(TAG, "PM1.0: %d, PM2.5: %d, PM10: %d, Measuring mode: %s.", pm1, pm25, pm10,
-           LOG_STR_ARG(pm2005_get_measuring_mode_string(sensor_measuring_mode)));
-
-  if (this->pm_1_0_sensor_ != nullptr) {
-    this->pm_1_0_sensor_->publish_state(pm1);
-  }
-  if (this->pm_2_5_sensor_ != nullptr) {
-    this->pm_2_5_sensor_->publish_state(pm25);
-  }
-  if (this->pm_10_0_sensor_ != nullptr) {
-    this->pm_10_0_sensor_->publish_state(pm10);
-  }
-
-  this->status_clear_warning();
-}
-
-void PM2005Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "PM2005:");
-  ESP_LOGCONFIG(TAG, "  Type: PM2%u05", this->sensor_type_ == PM2105);
-
-  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with PM2%u05 failed!", this->sensor_type_ == PM2105);
-  }
-
-  LOG_SENSOR("  ", "PM1.0", this->pm_1_0_sensor_);
-  LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
-  LOG_SENSOR("  ", "PM10 ", this->pm_10_0_sensor_);
-}
-
-}  // namespace pm2005
-}  // namespace esphome

esphome/components/pm2005/pm2005.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/i2c/i2c.h"
-
-namespace esphome {
-namespace pm2005 {
-
-enum SensorType {
-  PM2005,
-  PM2105,
-};
-
-class PM2005Component : public PollingComponent, public i2c::I2CDevice {
- public:
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
-
-  void set_sensor_type(SensorType sensor_type) { this->sensor_type_ = sensor_type; }
-
-  void set_pm_1_0_sensor(sensor::Sensor *pm_1_0_sensor) { this->pm_1_0_sensor_ = pm_1_0_sensor; }
-  void set_pm_2_5_sensor(sensor::Sensor *pm_2_5_sensor) { this->pm_2_5_sensor_ = pm_2_5_sensor; }
-  void set_pm_10_0_sensor(sensor::Sensor *pm_10_0_sensor) { this->pm_10_0_sensor_ = pm_10_0_sensor; }
-
-  void setup() override;
-  void dump_config() override;
-  void update() override;
-
- protected:
-  uint8_t sensor_situation_{0};
-  uint8_t data_buffer_[12];
-  SensorType sensor_type_{PM2005};
-
-  sensor::Sensor *pm_1_0_sensor_{nullptr};
-  sensor::Sensor *pm_2_5_sensor_{nullptr};
-  sensor::Sensor *pm_10_0_sensor_{nullptr};
-
-  uint8_t situation_value_index_{3};
-  uint8_t pm_1_0_value_index_{4};
-  uint8_t pm_2_5_value_index_{6};
-  uint8_t pm_10_0_value_index_{8};
-  uint8_t measuring_value_index_{10};
-};
-
-}  // namespace pm2005
-}  // namespace esphome

esphome/components/pm2005/sensor.py

@@ -1,86 +0,0 @@
-"""PM2005/2105 Sensor component for ESPHome."""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.components import i2c, sensor
-from esphome.const import (
-    CONF_ID,
-    CONF_PM_1_0,
-    CONF_PM_2_5,
-    CONF_PM_10_0,
-    CONF_TYPE,
-    DEVICE_CLASS_PM1,
-    DEVICE_CLASS_PM10,
-    DEVICE_CLASS_PM25,
-    ICON_CHEMICAL_WEAPON,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_MICROGRAMS_PER_CUBIC_METER,
-)
-
-DEPENDENCIES = ["i2c"]
-CODEOWNERS = ["@andrewjswan"]
-
-pm2005_ns = cg.esphome_ns.namespace("pm2005")
-PM2005Component = pm2005_ns.class_(
-    "PM2005Component", cg.PollingComponent, i2c.I2CDevice
-)
-
-SensorType = pm2005_ns.enum("SensorType")
-SENSOR_TYPE = {
-    "PM2005": SensorType.PM2005,
-    "PM2105": SensorType.PM2105,
-}
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(PM2005Component),
-            cv.Optional(CONF_TYPE, default="PM2005"): cv.enum(SENSOR_TYPE, upper=True),
-            cv.Optional(CONF_PM_1_0): sensor.sensor_schema(
-                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
-                icon=ICON_CHEMICAL_WEAPON,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_PM1,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ),
-            cv.Optional(CONF_PM_2_5): sensor.sensor_schema(
-                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
-                icon=ICON_CHEMICAL_WEAPON,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_PM25,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ),
-            cv.Optional(CONF_PM_10_0): sensor.sensor_schema(
-                unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
-                icon=ICON_CHEMICAL_WEAPON,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_PM10,
-                state_class=STATE_CLASS_MEASUREMENT,
-            ),
-        },
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x28)),
-)
-
-
-async def to_code(config) -> None:
-    """Code generation entry point."""
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-
-    cg.add(var.set_sensor_type(config[CONF_TYPE]))
-
-    if pm_1_0_config := config.get(CONF_PM_1_0):
-        sens = await sensor.new_sensor(pm_1_0_config)
-        cg.add(var.set_pm_1_0_sensor(sens))
-
-    if pm_2_5_config := config.get(CONF_PM_2_5):
-        sens = await sensor.new_sensor(pm_2_5_config)
-        cg.add(var.set_pm_2_5_sensor(sens))
-
-    if pm_10_0_config := config.get(CONF_PM_10_0):
-        sens = await sensor.new_sensor(pm_10_0_config)
-        cg.add(var.set_pm_10_0_sensor(sens))

esphome/components/prometheus/prometheus_handler.cpp

@@ -89,12 +89,6 @@ void PrometheusHandler::handleRequest(AsyncWebServerRequest *req) {
     this->valve_row_(stream, obj, area, node, friendly_name);
 #endif
 
-#ifdef USE_CLIMATE
-  this->climate_type_(stream);
-  for (auto *obj : App.get_climates())
-    this->climate_row_(stream, obj, area, node, friendly_name);
-#endif
-
   req->send(stream);
 }
 
@@ -830,174 +824,6 @@ void PrometheusHandler::valve_row_(AsyncResponseStream *stream, valve::Valve *ob
 }
 #endif
 
-#ifdef USE_CLIMATE
-void PrometheusHandler::climate_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_climate_setting gauge\n"));
-  stream->print(F("#TYPE esphome_climate_value gauge\n"));
-  stream->print(F("#TYPE esphome_climate_failed gauge\n"));
-}
-
-void PrometheusHandler::climate_setting_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
-                                             std::string &node, std::string &friendly_name, std::string &setting,
-                                             const LogString *setting_value) {
-  stream->print(F("esphome_climate_setting{id=\""));
-  stream->print(relabel_id_(obj).c_str());
-  add_area_label_(stream, area);
-  add_node_label_(stream, node);
-  add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
-  stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
-  stream->print(setting.c_str());
-  stream->print(F("\",setting_value=\""));
-  stream->print(LOG_STR_ARG(setting_value));
-  stream->print(F("\"} "));
-  stream->print(F("1.0"));
-  stream->print(F("\n"));
-}
-
-void PrometheusHandler::climate_value_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
-                                           std::string &node, std::string &friendly_name, std::string &category,
-                                           std::string &climate_value) {
-  stream->print(F("esphome_climate_value{id=\""));
-  stream->print(relabel_id_(obj).c_str());
-  add_area_label_(stream, area);
-  add_node_label_(stream, node);
-  add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
-  stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
-  stream->print(category.c_str());
-  stream->print(F("\"} "));
-  stream->print(climate_value.c_str());
-  stream->print(F("\n"));
-}
-
-void PrometheusHandler::climate_failed_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
-                                            std::string &node, std::string &friendly_name, std::string &category,
-                                            bool is_failed_value) {
-  stream->print(F("esphome_climate_failed{id=\""));
-  stream->print(relabel_id_(obj).c_str());
-  add_area_label_(stream, area);
-  add_node_label_(stream, node);
-  add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
-  stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
-  stream->print(category.c_str());
-  stream->print(F("\"} "));
-  if (is_failed_value) {
-    stream->print(F("1.0"));
-  } else {
-    stream->print(F("0.0"));
-  }
-  stream->print(F("\n"));
-}
-
-void PrometheusHandler::climate_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
-                                     std::string &node, std::string &friendly_name) {
-  if (obj->is_internal() && !this->include_internal_)
-    return;
-  // Data itself
-  bool any_failures = false;
-  std::string climate_mode_category = "mode";
-  const auto *climate_mode_value = climate::climate_mode_to_string(obj->mode);
-  climate_setting_row_(stream, obj, area, node, friendly_name, climate_mode_category, climate_mode_value);
-  const auto traits = obj->get_traits();
-  // Now see if traits is supported
-  int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
-  int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
-  // max temp
-  std::string max_temp = "maximum_temperature";
-  auto max_temp_value = value_accuracy_to_string(traits.get_visual_max_temperature(), target_accuracy);
-  climate_value_row_(stream, obj, area, node, friendly_name, max_temp, max_temp_value);
-  // max temp
-  std::string min_temp = "mininum_temperature";
-  auto min_temp_value = value_accuracy_to_string(traits.get_visual_min_temperature(), target_accuracy);
-  climate_value_row_(stream, obj, area, node, friendly_name, min_temp, min_temp_value);
-  // now check optional traits
-  if (traits.get_supports_current_temperature()) {
-    std::string current_temp = "current_temperature";
-    if (std::isnan(obj->current_temperature)) {
-      climate_failed_row_(stream, obj, area, node, friendly_name, current_temp, true);
-      any_failures = true;
-    } else {
-      auto current_temp_value = value_accuracy_to_string(obj->current_temperature, current_accuracy);
-      climate_value_row_(stream, obj, area, node, friendly_name, current_temp, current_temp_value);
-      climate_failed_row_(stream, obj, area, node, friendly_name, current_temp, false);
-    }
-  }
-  if (traits.get_supports_current_humidity()) {
-    std::string current_humidity = "current_humidity";
-    if (std::isnan(obj->current_humidity)) {
-      climate_failed_row_(stream, obj, area, node, friendly_name, current_humidity, true);
-      any_failures = true;
-    } else {
-      auto current_humidity_value = value_accuracy_to_string(obj->current_humidity, 0);
-      climate_value_row_(stream, obj, area, node, friendly_name, current_humidity, current_humidity_value);
-      climate_failed_row_(stream, obj, area, node, friendly_name, current_humidity, false);
-    }
-  }
-  if (traits.get_supports_target_humidity()) {
-    std::string target_humidity = "target_humidity";
-    if (std::isnan(obj->target_humidity)) {
-      climate_failed_row_(stream, obj, area, node, friendly_name, target_humidity, true);
-      any_failures = true;
-    } else {
-      auto target_humidity_value = value_accuracy_to_string(obj->target_humidity, 0);
-      climate_value_row_(stream, obj, area, node, friendly_name, target_humidity, target_humidity_value);
-      climate_failed_row_(stream, obj, area, node, friendly_name, target_humidity, false);
-    }
-  }
-  if (traits.get_supports_two_point_target_temperature()) {
-    std::string target_temp_low = "target_temperature_low";
-    auto target_temp_low_value = value_accuracy_to_string(obj->target_temperature_low, target_accuracy);
-    climate_value_row_(stream, obj, area, node, friendly_name, target_temp_low, target_temp_low_value);
-    std::string target_temp_high = "target_temperature_high";
-    auto target_temp_high_value = value_accuracy_to_string(obj->target_temperature_high, target_accuracy);
-    climate_value_row_(stream, obj, area, node, friendly_name, target_temp_high, target_temp_high_value);
-  } else {
-    std::string target_temp = "target_temperature";
-    auto target_temp_value = value_accuracy_to_string(obj->target_temperature, target_accuracy);
-    climate_value_row_(stream, obj, area, node, friendly_name, target_temp, target_temp_value);
-  }
-  if (traits.get_supports_action()) {
-    std::string climate_trait_category = "action";
-    const auto *climate_trait_value = climate::climate_action_to_string(obj->action);
-    climate_setting_row_(stream, obj, area, node, friendly_name, climate_trait_category, climate_trait_value);
-  }
-  if (traits.get_supports_fan_modes()) {
-    std::string climate_trait_category = "fan_mode";
-    if (obj->fan_mode.has_value()) {
-      const auto *climate_trait_value = climate::climate_fan_mode_to_string(obj->fan_mode.value());
-      climate_setting_row_(stream, obj, area, node, friendly_name, climate_trait_category, climate_trait_value);
-      climate_failed_row_(stream, obj, area, node, friendly_name, climate_trait_category, false);
-    } else {
-      climate_failed_row_(stream, obj, area, node, friendly_name, climate_trait_category, true);
-      any_failures = true;
-    }
-  }
-  if (traits.get_supports_presets()) {
-    std::string climate_trait_category = "preset";
-    if (obj->preset.has_value()) {
-      const auto *climate_trait_value = climate::climate_preset_to_string(obj->preset.value());
-      climate_setting_row_(stream, obj, area, node, friendly_name, climate_trait_category, climate_trait_value);
-      climate_failed_row_(stream, obj, area, node, friendly_name, climate_trait_category, false);
-    } else {
-      climate_failed_row_(stream, obj, area, node, friendly_name, climate_trait_category, true);
-      any_failures = true;
-    }
-  }
-  if (traits.get_supports_swing_modes()) {
-    std::string climate_trait_category = "swing_mode";
-    const auto *climate_trait_value = climate::climate_swing_mode_to_string(obj->swing_mode);
-    climate_setting_row_(stream, obj, area, node, friendly_name, climate_trait_category, climate_trait_value);
-  }
-  std::string all_climate_category = "all";
-  climate_failed_row_(stream, obj, area, node, friendly_name, all_climate_category, any_failures);
-}
-#endif
-
 }  // namespace prometheus
 }  // namespace esphome
 #endif

esphome/components/prometheus/prometheus_handler.h

@@ -8,9 +8,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/controller.h"
 #include "esphome/core/entity_base.h"
-#ifdef USE_CLIMATE
-#include "esphome/core/log.h"
-#endif
 
 namespace esphome {
 namespace prometheus {
@@ -172,20 +169,6 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
                   std::string &friendly_name);
 #endif
 
-#ifdef USE_CLIMATE
-  /// Return the type for prometheus
-  void climate_type_(AsyncResponseStream *stream);
-  /// Return the climate state as prometheus data point
-  void climate_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
-                    std::string &friendly_name);
-  void climate_failed_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
-                           std::string &friendly_name, std::string &category, bool is_failed_value);
-  void climate_setting_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
-                            std::string &friendly_name, std::string &setting, const LogString *setting_value);
-  void climate_value_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
-                          std::string &friendly_name, std::string &category, std::string &climate_value);
-#endif
-
   web_server_base::WebServerBase *base_;
   bool include_internal_{false};
   std::map<EntityBase *, std::string> relabel_map_id_;

esphome/components/psram/__init__.py

@@ -16,8 +16,6 @@ from esphome.const import (
     CONF_ID,
     CONF_MODE,
     CONF_SPEED,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
     PLATFORM_ESP32,
 )
 from esphome.core import CORE
@@ -112,11 +110,11 @@ async def to_code(config):
         add_idf_sdkconfig_option(f"{SPIRAM_MODES[config[CONF_MODE]]}", True)
         add_idf_sdkconfig_option(f"{SPIRAM_SPEEDS[config[CONF_SPEED]]}", True)
         if config[CONF_MODE] == TYPE_OCTAL and config[CONF_SPEED] == 120e6:
-            add_idf_sdkconfig_option("CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240", True)
-            if CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(5, 4, 0):
-                add_idf_sdkconfig_option(
-                    "CONFIG_SPIRAM_TIMING_TUNING_POINT_VIA_TEMPERATURE_SENSOR", True
-                )
+            add_idf_sdkconfig_option("CONFIG_ESP32S3_DEFAULT_CPU_FREQ_240", True)
+            # This works only on IDF 5.4.x but does no harm on earlier versions
+            add_idf_sdkconfig_option(
+                "CONFIG_SPIRAM_TIMING_TUNING_POINT_VIA_TEMPERATURE_SENSOR", True
+            )
         if config[CONF_ENABLE_ECC]:
             add_idf_sdkconfig_option("CONFIG_SPIRAM_ECC_ENABLE", True)
 

esphome/components/qspi_dbi/__init__.py

@@ -1,3 +1,4 @@
 CODEOWNERS = ["@clydebarrow"]
 
 CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
+CONF_DRAW_ROUNDING = "draw_rounding"

esphome/components/qspi_dbi/display.py

@@ -1,7 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display, spi
-from esphome.components.const import CONF_DRAW_ROUNDING
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BRIGHTNESS,
@@ -25,7 +24,7 @@ from esphome.const import (
 )
 from esphome.core import TimePeriod
 
-from . import CONF_DRAW_FROM_ORIGIN
+from . import CONF_DRAW_FROM_ORIGIN, CONF_DRAW_ROUNDING
 from .models import DriverChip
 
 DEPENDENCIES = ["spi"]

esphome/components/qspi_dbi/models.py

@@ -1,7 +1,8 @@
 # Commands
-from esphome.components.const import CONF_DRAW_ROUNDING
 from esphome.const import CONF_INVERT_COLORS, CONF_SWAP_XY
 
+from . import CONF_DRAW_ROUNDING
+
 SW_RESET_CMD = 0x01
 SLEEP_IN = 0x10
 SLEEP_OUT = 0x11

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -208,6 +208,7 @@ void RemoteReceiverComponent::loop() {
     this->store_.buffer_read = next_read;
 
     if (!this->temp_.empty()) {
+      this->temp_.push_back(-this->idle_us_);
       this->call_listeners_dumpers_();
     }
   }
@@ -218,9 +219,11 @@ void RemoteReceiverComponent::loop() {
     this->decode_rmt_(item, len / sizeof(rmt_item32_t));
     vRingbufferReturnItem(this->ringbuf_, item);
 
-    if (!this->temp_.empty()) {
-      this->call_listeners_dumpers_();
-    }
+    if (this->temp_.empty())
+      return;
+
+    this->temp_.push_back(-this->idle_us_);
+    this->call_listeners_dumpers_();
   }
 #endif
 }
@@ -231,7 +234,6 @@ void RemoteReceiverComponent::decode_rmt_(rmt_symbol_word_t *item, size_t item_c
 void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count) {
 #endif
   bool prev_level = false;
-  bool idle_level = false;
   uint32_t prev_length = 0;
   this->temp_.clear();
   int32_t multiplier = this->pin_->is_inverted() ? -1 : 1;
@@ -264,7 +266,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
     } else if ((bool(item[i].level0) == prev_level) || (item[i].duration0 < filter_ticks)) {
       prev_length += item[i].duration0;
     } else {
-      if (prev_length >= filter_ticks) {
+      if (prev_length > 0) {
         if (prev_level) {
           this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
         } else {
@@ -274,7 +276,6 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
       prev_level = bool(item[i].level0);
       prev_length = item[i].duration0;
     }
-    idle_level = !bool(item[i].level0);
 
     if (item[i].duration1 == 0u) {
       // EOF, sometimes garbage follows, break early
@@ -282,7 +283,7 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
     } else if ((bool(item[i].level1) == prev_level) || (item[i].duration1 < filter_ticks)) {
       prev_length += item[i].duration1;
     } else {
-      if (prev_length >= filter_ticks) {
+      if (prev_length > 0) {
         if (prev_level) {
           this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
         } else {
@@ -292,22 +293,14 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t item_count)
       prev_level = bool(item[i].level1);
       prev_length = item[i].duration1;
     }
-    idle_level = !bool(item[i].level1);
   }
-  if (prev_length >= filter_ticks && prev_level != idle_level) {
+  if (prev_length > 0) {
     if (prev_level) {
       this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
     } else {
       this->temp_.push_back(-int32_t(this->to_microseconds_(prev_length)) * multiplier);
     }
   }
-  if (!this->temp_.empty()) {
-    if (idle_level) {
-      this->temp_.push_back(this->idle_us_ * multiplier);
-    } else {
-      this->temp_.push_back(-int32_t(this->idle_us_) * multiplier);
-    }
-  }
 }
 
 }  // namespace remote_receiver

esphome/components/scd30/sensor.py

@@ -18,8 +18,6 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
-    CONF_AUTOMATIC_SELF_CALIBRATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION,
 )
 
 DEPENDENCIES = ["i2c"]
@@ -35,7 +33,10 @@ ForceRecalibrationWithReference = scd30_ns.class_(
     "ForceRecalibrationWithReference", automation.Action
 )
 
+CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
+CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
+
 
 CONFIG_SCHEMA = (
     cv.Schema(

esphome/components/scd4x/sensor.py

@@ -20,10 +20,6 @@ from esphome.const import (
     UNIT_CELSIUS,
     UNIT_PARTS_PER_MILLION,
     UNIT_PERCENT,
-    CONF_AUTOMATIC_SELF_CALIBRATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION,
-    CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE,
-    CONF_MEASUREMENT_MODE,
 )
 
 CODEOWNERS = ["@sjtrny", "@martgras"]
@@ -51,6 +47,11 @@ FactoryResetAction = scd4x_ns.class_("FactoryResetAction", automation.Action)
 
 
 CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
+CONF_AMBIENT_PRESSURE_COMPENSATION = "ambient_pressure_compensation"
+CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE = "ambient_pressure_compensation_source"
+CONF_AUTOMATIC_SELF_CALIBRATION = "automatic_self_calibration"
+CONF_MEASUREMENT_MODE = "measurement_mode"
+
 
 CONFIG_SCHEMA = (
     cv.Schema(

esphome/components/sdp3x/sensor.py

@@ -5,7 +5,6 @@ from esphome.const import (
     DEVICE_CLASS_PRESSURE,
     STATE_CLASS_MEASUREMENT,
     UNIT_HECTOPASCAL,
-    CONF_MEASUREMENT_MODE,
 )
 
 DEPENDENCIES = ["i2c"]
@@ -23,7 +22,7 @@ MEASUREMENT_MODE = {
     "mass_flow": MeasurementMode.MASS_FLOW_AVG,
     "differential_pressure": MeasurementMode.DP_AVG,
 }
-
+CONF_MEASUREMENT_MODE = "measurement_mode"
 
 CONFIG_SCHEMA = (
     sensor.sensor_schema(

esphome/components/sht4x/sht4x.cpp

@@ -12,22 +12,14 @@ void SHT4XComponent::start_heater_() {
   uint8_t cmd[] = {MEASURECOMMANDS[this->heater_command_]};
 
   ESP_LOGD(TAG, "Heater turning on");
-  if (this->write(cmd, 1) != i2c::ERROR_OK) {
-    this->status_set_error("Failed to turn on heater");
-  }
+  this->write(cmd, 1);
 }
 
 void SHT4XComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up sht4x...");
 
-  auto err = this->write(nullptr, 0);
-  if (err != i2c::ERROR_OK) {
-    this->mark_failed();
-    return;
-  }
-
-  if (std::isfinite(this->duty_cycle_) && this->duty_cycle_ > 0.0f) {
-    uint32_t heater_interval = static_cast<uint32_t>(static_cast<uint16_t>(this->heater_time_) / this->duty_cycle_);
+  if (this->duty_cycle_ > 0.0) {
+    uint32_t heater_interval = (uint32_t) (this->heater_time_ / this->duty_cycle_);
     ESP_LOGD(TAG, "Heater interval: %" PRIu32, heater_interval);
 
     if (this->heater_power_ == SHT4X_HEATERPOWER_HIGH) {
@@ -55,50 +47,37 @@ void SHT4XComponent::setup() {
   }
 }
 
-void SHT4XComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "SHT4x:");
-  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with SHT4x failed!");
-  }
-}
+void SHT4XComponent::dump_config() { LOG_I2C_DEVICE(this); }
 
 void SHT4XComponent::update() {
   // Send command
-  if (!this->write_command(MEASURECOMMANDS[this->precision_])) {
-    // Warning will be printed only if warning status is not set yet
-    this->status_set_warning("Failed to send measurement command");
-    return;
-  }
+  this->write_command(MEASURECOMMANDS[this->precision_]);
 
   this->set_timeout(10, [this]() {
     uint16_t buffer[2];
 
     // Read measurement
-    if (!this->read_data(buffer, 2)) {
-      // Using ESP_LOGW to force the warning to be printed
-      ESP_LOGW(TAG, "Sensor read failed");
-      this->status_set_warning();
-      return;
-    }
+    bool read_status = this->read_data(buffer, 2);
 
-    this->status_clear_warning();
+    if (read_status) {
+      // Evaluate and publish measurements
+      if (this->temp_sensor_ != nullptr) {
+        // Temp is contained in the first result word
+        float sensor_value_temp = buffer[0];
+        float temp = -45 + 175 * sensor_value_temp / 65535;
 
-    // Evaluate and publish measurements
-    if (this->temp_sensor_ != nullptr) {
-      // Temp is contained in the first result word
-      float sensor_value_temp = buffer[0];
-      float temp = -45 + 175 * sensor_value_temp / 65535;
+        this->temp_sensor_->publish_state(temp);
+      }
 
-      this->temp_sensor_->publish_state(temp);
-    }
+      if (this->humidity_sensor_ != nullptr) {
+        // Relative humidity is in the second result word
+        float sensor_value_rh = buffer[1];
+        float rh = -6 + 125 * sensor_value_rh / 65535;
 
-    if (this->humidity_sensor_ != nullptr) {
-      // Relative humidity is in the second result word
-      float sensor_value_rh = buffer[1];
-      float rh = -6 + 125 * sensor_value_rh / 65535;
-
-      this->humidity_sensor_->publish_state(rh);
+        this->humidity_sensor_->publish_state(rh);
+      }
+    } else {
+      ESP_LOGD(TAG, "Sensor read failed");
     }
   });
 }

esphome/components/sht4x/sht4x.h

@@ -13,7 +13,7 @@ enum SHT4XPRECISION { SHT4X_PRECISION_HIGH = 0, SHT4X_PRECISION_MED, SHT4X_PRECI
 
 enum SHT4XHEATERPOWER { SHT4X_HEATERPOWER_HIGH, SHT4X_HEATERPOWER_MED, SHT4X_HEATERPOWER_LOW };
 
-enum SHT4XHEATERTIME : uint16_t { SHT4X_HEATERTIME_LONG = 1100, SHT4X_HEATERTIME_SHORT = 110 };
+enum SHT4XHEATERTIME { SHT4X_HEATERTIME_LONG = 1100, SHT4X_HEATERTIME_SHORT = 110 };
 
 class SHT4XComponent : public PollingComponent, public sensirion_common::SensirionI2CDevice {
  public:

esphome/components/tt21100/touchscreen/tt21100.cpp

@@ -68,7 +68,7 @@ void TT21100Touchscreen::setup() {
       this->x_raw_max_ = this->display_->get_native_width();
     }
     if (this->y_raw_max_ == this->y_raw_min_) {
-      this->x_raw_max_ = this->display_->get_native_height();
+      this->y_raw_max_ = this->display_->get_native_height();
     }
   }
 

esphome/components/uptime/text_sensor/__init__.py

@@ -1,59 +1,19 @@
 import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_FORMAT,
-    CONF_HOURS,
-    CONF_ID,
-    CONF_MINUTES,
-    CONF_SECONDS,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-    ICON_TIMER,
-)
+from esphome.const import ENTITY_CATEGORY_DIAGNOSTIC, ICON_TIMER
 
 uptime_ns = cg.esphome_ns.namespace("uptime")
 UptimeTextSensor = uptime_ns.class_(
     "UptimeTextSensor", text_sensor.TextSensor, cg.PollingComponent
 )
-
-CONF_SEPARATOR = "separator"
-CONF_DAYS = "days"
-CONF_EXPAND = "expand"
-
-CONFIG_SCHEMA = (
-    text_sensor.text_sensor_schema(
-        UptimeTextSensor,
-        icon=ICON_TIMER,
-        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-    )
-    .extend(
-        {
-            cv.Optional(CONF_FORMAT, default={}): cv.Schema(
-                {
-                    cv.Optional(CONF_DAYS, default="d"): cv.string_strict,
-                    cv.Optional(CONF_HOURS, default="h"): cv.string_strict,
-                    cv.Optional(CONF_MINUTES, default="m"): cv.string_strict,
-                    cv.Optional(CONF_SECONDS, default="s"): cv.string_strict,
-                    cv.Optional(CONF_SEPARATOR, default=""): cv.string_strict,
-                    cv.Optional(CONF_EXPAND, default=False): cv.boolean,
-                }
-            )
-        }
-    )
-    .extend(cv.polling_component_schema("30s"))
-)
+CONFIG_SCHEMA = text_sensor.text_sensor_schema(
+    UptimeTextSensor,
+    icon=ICON_TIMER,
+    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+).extend(cv.polling_component_schema("30s"))
 
 
 async def to_code(config):
-    format = config[CONF_FORMAT]
-    var = cg.new_Pvariable(
-        config[CONF_ID],
-        format[CONF_DAYS],
-        format[CONF_HOURS],
-        format[CONF_MINUTES],
-        format[CONF_SECONDS],
-        format[CONF_SEPARATOR],
-        format[CONF_EXPAND],
-    )
-    await text_sensor.register_text_sensor(var, config)
+    var = await text_sensor.new_text_sensor(config)
     await cg.register_component(var, config)

esphome/components/uptime/text_sensor/uptime_text_sensor.cpp

@@ -16,11 +16,6 @@ void UptimeTextSensor::setup() {
   this->update();
 }
 
-void UptimeTextSensor::insert_buffer_(std::string &buffer, const char *key, unsigned value) const {
-  buffer.insert(0, this->separator_);
-  buffer.insert(0, str_sprintf("%u%s", value, key));
-}
-
 void UptimeTextSensor::update() {
   auto now = millis();
   // get whole seconds since last update. Note that even if the millis count has overflowed between updates,
@@ -37,25 +32,25 @@ void UptimeTextSensor::update() {
     unsigned remainder = uptime % 60;
     uptime /= 60;
     if (interval < 30) {
-      this->insert_buffer_(buffer, this->seconds_text_, remainder);
-      if (!this->expand_ && uptime == 0)
+      buffer.insert(0, str_sprintf("%us", remainder));
+      if (uptime == 0)
         break;
     }
     remainder = uptime % 60;
     uptime /= 60;
     if (interval < 1800) {
-      this->insert_buffer_(buffer, this->minutes_text_, remainder);
-      if (!this->expand_ && uptime == 0)
+      buffer.insert(0, str_sprintf("%um", remainder));
+      if (uptime == 0)
         break;
     }
     remainder = uptime % 24;
     uptime /= 24;
     if (interval < 12 * 3600) {
-      this->insert_buffer_(buffer, this->hours_text_, remainder);
-      if (!this->expand_ && uptime == 0)
+      buffer.insert(0, str_sprintf("%uh", remainder));
+      if (uptime == 0)
         break;
     }
-    this->insert_buffer_(buffer, this->days_text_, (unsigned) uptime);
+    buffer.insert(0, str_sprintf("%ud", (unsigned) uptime));
     break;
   }
   this->publish_state(buffer);

esphome/components/uptime/text_sensor/uptime_text_sensor.h

@@ -10,32 +10,13 @@ namespace uptime {
 
 class UptimeTextSensor : public text_sensor::TextSensor, public PollingComponent {
  public:
-  UptimeTextSensor(const char *days_text, const char *hours_text, const char *minutes_text, const char *seconds_text,
-                   const char *separator, bool expand)
-      : days_text_(days_text),
-        hours_text_(hours_text),
-        minutes_text_(minutes_text),
-        seconds_text_(seconds_text),
-        separator_(separator),
-        expand_(expand) {}
   void update() override;
   void dump_config() override;
   void setup() override;
 
   float get_setup_priority() const override;
-  void set_days(const char *days_text) { this->days_text_ = days_text; }
-  void set_hours(const char *hours_text) { this->hours_text_ = hours_text; }
-  void set_minutes(const char *minutes_text) { this->minutes_text_ = minutes_text; }
-  void set_seconds(const char *seconds_text) { this->seconds_text_ = seconds_text; }
 
  protected:
-  void insert_buffer_(std::string &buffer, const char *key, unsigned value) const;
-  const char *days_text_;
-  const char *hours_text_;
-  const char *minutes_text_;
-  const char *seconds_text_;
-  const char *separator_;
-  bool expand_{};
   uint32_t uptime_{0};  // uptime in seconds, will overflow after 136 years
   uint32_t last_ms_{0};
 };