Merge pull request #6122 from esphome/bump-2023.12.8

2023.12.8

.devcontainer/devcontainer.json

@@ -37,6 +37,7 @@
           "!secret scalar",
           "!lambda scalar",
           "!extend scalar",
+          "!remove scalar",
           "!include_dir_named scalar",
           "!include_dir_list scalar",
           "!include_dir_merge_list scalar",

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

@@ -0,0 +1,97 @@
+name: Build Image
+inputs:
+  platform:
+    description: "Platform to build for"
+    required: true
+    example: "linux/amd64"
+  target:
+    description: "Target to build"
+    required: true
+    example: "docker"
+  baseimg:
+    description: "Base image type"
+    required: true
+    example: "docker"
+  suffix:
+    description: "Suffix to add to tags"
+    required: true
+  version:
+    description: "Version to build"
+    required: true
+    example: "2023.12.0"
+runs:
+  using: "composite"
+  steps:
+    - name: Generate short tags
+      id: tags
+      shell: bash
+      run: |
+        output=$(docker/generate_tags.py \
+          --tag "${{ inputs.version }}" \
+          --suffix "${{ inputs.suffix }}")
+        echo $output
+        for l in $output; do
+          echo $l >> $GITHUB_OUTPUT
+        done
+
+    - name: Build and push to ghcr by digest
+      id: build-ghcr
+      uses: docker/build-push-action@v5.0.0
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: ${{ inputs.platform }}
+        target: ${{ inputs.target }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        build-args: |
+          BASEIMGTYPE=${{ inputs.baseimg }}
+          BUILD_VERSION=${{ inputs.version }}
+        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.target }}/ghcr
+        digest="${{ steps.build-ghcr.outputs.digest }}"
+        touch "/tmp/digests/${{ inputs.target }}/ghcr/${digest#sha256:}"
+
+    - name: Upload ghcr digest
+      uses: actions/upload-artifact@v3.1.3
+      with:
+        name: digests-${{ inputs.target }}-ghcr
+        path: /tmp/digests/${{ inputs.target }}/ghcr/*
+        if-no-files-found: error
+        retention-days: 1
+
+    - name: Build and push to dockerhub by digest
+      id: build-dockerhub
+      uses: docker/build-push-action@v5.0.0
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: ${{ inputs.platform }}
+        target: ${{ inputs.target }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        build-args: |
+          BASEIMGTYPE=${{ inputs.baseimg }}
+          BUILD_VERSION=${{ inputs.version }}
+        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.target }}/dockerhub
+        digest="${{ steps.build-dockerhub.outputs.digest }}"
+        touch "/tmp/digests/${{ inputs.target }}/dockerhub/${digest#sha256:}"
+
+    - name: Upload dockerhub digest
+      uses: actions/upload-artifact@v3.1.3
+      with:
+        name: digests-${{ inputs.target }}-dockerhub
+        path: /tmp/digests/${{ inputs.target }}/dockerhub/*
+        if-no-files-found: error
+        retention-days: 1

.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@v4.7.0
+      uses: actions/setup-python@v5.0.0
       with:
         python-version: ${{ inputs.python-version }}
     - name: Restore Python virtual environment

.github/workflows/ci-docker.yml

@@ -42,7 +42,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4.1.1
       - name: Set up Python
-        uses: actions/setup-python@v4.7.1
+        uses: actions/setup-python@v5.0.0
         with:
           python-version: "3.9"
       - name: Set up Docker Buildx

.github/workflows/ci.yml

@@ -40,7 +40,7 @@ jobs:
         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@v4.7.1
+        uses: actions/setup-python@v5.0.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
       - name: Restore Python virtual environment

.github/workflows/lock.yml

@@ -18,7 +18,7 @@ jobs:
   lock:
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@v4.0.1
+      - uses: dessant/lock-threads@v5.0.1
         with:
           pr-inactive-days: "1"
           pr-lock-reason: ""

.github/workflows/needs-docs.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check for needs-docs label
-        uses: actions/github-script@v6.4.1
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             const { data: labels } = await github.rest.issues.listLabelsOnIssue({

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4.1.1
       - name: Set up Python
-        uses: actions/setup-python@v4.7.1
+        uses: actions/setup-python@v5.0.0
         with:
           python-version: "3.x"
       - name: Set up python environment
@@ -63,40 +63,31 @@ jobs:
         run: twine upload dist/*
 
   deploy-docker:
-    name: Build and publish ESPHome ${{ matrix.image.title}}
+    name: Build ESPHome ${{ matrix.platform }}
     if: github.repository == 'esphome/esphome'
     permissions:
       contents: read
       packages: write
     runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.image.title == 'lint' }}
     needs: [init]
     strategy:
       fail-fast: false
       matrix:
-        image:
-          - title: "ha-addon"
-            suffix: "hassio"
-            target: "hassio"
-            baseimg: "hassio"
-          - title: "docker"
-            suffix: ""
-            target: "docker"
-            baseimg: "docker"
-          - title: "lint"
-            suffix: "lint"
-            target: "lint"
-            baseimg: "docker"
+        platform:
+          - linux/amd64
+          - linux/arm/v7
+          - linux/arm64
     steps:
       - uses: actions/checkout@v4.1.1
       - name: Set up Python
-        uses: actions/setup-python@v4.7.1
+        uses: actions/setup-python@v5.0.0
         with:
           python-version: "3.9"
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3.0.0
       - name: Set up QEMU
+        if: matrix.platform != 'linux/amd64'
         uses: docker/setup-qemu-action@v3.0.0
 
       - name: Log in to docker hub
@@ -111,37 +102,108 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Build docker
+        uses: ./.github/actions/build-image
+        with:
+          platform: ${{ matrix.platform }}
+          target: docker
+          baseimg: docker
+          suffix: ""
+          version: ${{ needs.init.outputs.tag }}
+
+      - name: Build ha-addon
+        uses: ./.github/actions/build-image
+        with:
+          platform: ${{ matrix.platform }}
+          target: hassio
+          baseimg: hassio
+          suffix: "hassio"
+          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 }}
+
+  deploy-manifest:
+    name: Publish ESPHome ${{ matrix.image.title }} to ${{ matrix.registry }}
+    runs-on: ubuntu-latest
+    needs:
+      - init
+      - deploy-docker
+    if: github.repository == 'esphome/esphome'
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      matrix:
+        image:
+          - title: "ha-addon"
+            target: "hassio"
+            suffix: "hassio"
+          - title: "docker"
+            target: "docker"
+            suffix: ""
+          - title: "lint"
+            target: "lint"
+            suffix: "lint"
+        registry:
+          - ghcr
+          - dockerhub
+    steps:
+      - uses: actions/checkout@v4.1.1
+      - name: Download digests
+        uses: actions/download-artifact@v3.0.2
+        with:
+          name: digests-${{ matrix.image.target }}-${{ matrix.registry }}
+          path: /tmp/digests
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.0.0
+
+      - name: Log in to docker hub
+        if: matrix.registry == 'dockerhub'
+        uses: docker/login-action@v3.0.0
+        with:
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Log in to the GitHub container registry
+        if: matrix.registry == 'ghcr'
+        uses: docker/login-action@v3.0.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Generate short tags
         id: tags
         run: |
-          docker/generate_tags.py \
+          output=$(docker/generate_tags.py \
             --tag "${{ needs.init.outputs.tag }}" \
-            --suffix "${{ matrix.image.suffix }}"
+            --suffix "${{ matrix.image.suffix }}" \
+            --registry "${{ matrix.registry }}")
+          echo $output
+          for l in $output; do
+            echo $l >> $GITHUB_OUTPUT
+          done
 
-      - name: Build and push
-        uses: docker/build-push-action@v5.0.0
-        with:
-          context: .
-          file: ./docker/Dockerfile
-          platforms: linux/amd64,linux/arm/v7,linux/arm64
-          target: ${{ matrix.image.target }}
-          push: true
-          # yamllint disable rule:line-length
-          cache-from: type=registry,ref=ghcr.io/${{ steps.tags.outputs.image }}:cache-${{ steps.tags.outputs.channel }}
-          cache-to: type=registry,ref=ghcr.io/${{ steps.tags.outputs.image }}:cache-${{ steps.tags.outputs.channel }},mode=max
-          # yamllint enable rule:line-length
-          tags: ${{ steps.tags.outputs.tags }}
-          build-args: |
-            BASEIMGTYPE=${{ matrix.image.baseimg }}
-            BUILD_VERSION=${{ needs.init.outputs.tag }}
+      - name: Create manifest list and push
+        working-directory: /tmp/digests
+        run: |
+          docker buildx imagetools create $(jq -Rcnr 'inputs | . / "," | map("-t " + .) | join(" ")' <<< "${{ steps.tags.outputs.tags}}") \
+            $(printf '${{ steps.tags.outputs.image }}@sha256:%s ' *)
 
   deploy-ha-addon-repo:
     if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
-    needs: [deploy-docker]
+    needs: [deploy-manifest]
     steps:
       - name: Trigger Workflow
-        uses: actions/github-script@v6.4.1
+        uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ secrets.DEPLOY_HA_ADDON_REPO_TOKEN }}
           script: |

.github/workflows/stale.yml

@@ -18,7 +18,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v8.0.0
+      - uses: actions/stale@v9.0.0
         with:
           days-before-pr-stale: 90
           days-before-pr-close: 7
@@ -38,7 +38,7 @@ jobs:
   close-issues:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v8.0.0
+      - uses: actions/stale@v9.0.0
         with:
           days-before-pr-stale: -1
           days-before-pr-close: -1

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

@@ -22,7 +22,7 @@ jobs:
           path: lib/home-assistant
 
       - name: Setup Python
-        uses: actions/setup-python@v4.7.1
+        uses: actions/setup-python@v5.0.0
         with:
           python-version: 3.11
 

.github/workflows/yaml-lint.yml

@@ -19,4 +19,4 @@ jobs:
       - name: Check out code from GitHub
         uses: actions/checkout@v4.1.1
       - name: Run yamllint
-        uses: frenck/action-yamllint@v1.4.1
+        uses: frenck/action-yamllint@v1.4.2

.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 23.11.0
+    rev: 23.12.0
     hooks:
       - id: black
         args:

CODEOWNERS

@@ -12,6 +12,7 @@ esphome/core/* @esphome/core
 
 # Integrations
 esphome/components/a01nyub/* @MrSuicideParrot
+esphome/components/a02yyuw/* @TH-Braemer
 esphome/components/absolute_humidity/* @DAVe3283
 esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
@@ -88,8 +89,9 @@ esphome/components/ds1307/* @badbadc0ffee
 esphome/components/dsmr/* @glmnet @zuidwijk
 esphome/components/duty_time/* @dudanov
 esphome/components/ee895/* @Stock-M
-esphome/components/ektf2232/* @jesserockz
+esphome/components/ektf2232/touchscreen/* @jesserockz
 esphome/components/emc2101/* @ellull
+esphome/components/ens160/* @vincentscode
 esphome/components/ens210/* @itn3rd77
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @Rapsssito @jesserockz
@@ -100,7 +102,6 @@ esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
-esphome/components/esp_adf/* @jesserockz
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/exposure_notifications/* @OttoWinter
 esphome/components/ezo/* @ssieb
@@ -110,19 +111,24 @@ esphome/components/fastled_base/* @OttoWinter
 esphome/components/feedback/* @ianchi
 esphome/components/fingerprint_grow/* @OnFreund @loongyh
 esphome/components/fs3000/* @kahrendt
+esphome/components/ft5x06/* @clydebarrow
+esphome/components/ft63x6/* @gpambrozio
 esphome/components/gcja5/* @gcormier
 esphome/components/globals/* @esphome/core
 esphome/components/gp8403/* @jesserockz
 esphome/components/gpio/* @esphome/core
 esphome/components/gps/* @coogle
 esphome/components/graph/* @synco
+esphome/components/graphical_display_menu/* @MrMDavidson
 esphome/components/gree/* @orestismers
 esphome/components/grove_tb6612fng/* @max246
 esphome/components/growatt_solar/* @leeuwte
+esphome/components/gt911/* @clydebarrow @jesserockz
 esphome/components/haier/* @paveldn
 esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
+esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal
 esphome/components/hm3301/* @freekode
@@ -234,11 +240,17 @@ esphome/components/pmwcs3/* @SeByDocKy
 esphome/components/pn532/* @OttoWinter @jesserockz
 esphome/components/pn532_i2c/* @OttoWinter @jesserockz
 esphome/components/pn532_spi/* @OttoWinter @jesserockz
+esphome/components/pn7150/* @jesserockz @kbx81
+esphome/components/pn7150_i2c/* @jesserockz @kbx81
+esphome/components/pn7160/* @jesserockz @kbx81
+esphome/components/pn7160_i2c/* @jesserockz @kbx81
+esphome/components/pn7160_spi/* @jesserockz @kbx81
 esphome/components/power_supply/* @esphome/core
 esphome/components/preferences/* @esphome/core
 esphome/components/psram/* @esphome/core
 esphome/components/pulse_meter/* @TrentHouliston @cstaahl @stevebaxter
 esphome/components/pvvx_mithermometer/* @pasiz
+esphome/components/pylontech/* @functionpointer
 esphome/components/qmp6988/* @andrewpc
 esphome/components/qr_code/* @wjtje
 esphome/components/qwiic_pir/* @kahrendt
@@ -327,7 +339,7 @@ esphome/components/tmp1075/* @sybrenstuvel
 esphome/components/tmp117/* @Azimath
 esphome/components/tof10120/* @wstrzalka
 esphome/components/toshiba/* @kbx81
-esphome/components/touchscreen/* @jesserockz
+esphome/components/touchscreen/* @jesserockz @nielsnl68
 esphome/components/tsl2591/* @wjcarpenter
 esphome/components/tt21100/* @kroimon
 esphome/components/tuya/binary_sensor/* @jesserockz
@@ -360,6 +372,6 @@ esphome/components/xiaomi_mhoc303/* @drug123
 esphome/components/xiaomi_mhoc401/* @vevsvevs
 esphome/components/xiaomi_rtcgq02lm/* @jesserockz
 esphome/components/xl9535/* @mreditor97
-esphome/components/xpt2046/* @nielsnl68 @numo68
+esphome/components/xpt2046/touchscreen/* @nielsnl68 @numo68
 esphome/components/zhlt01/* @cfeenstra1024
 esphome/components/zio_ultrasonic/* @kahrendt

CONTRIBUTING.md

@@ -10,5 +10,3 @@ Things to note when contributing:
    for more information.
  - Please also update the tests in the `tests/` folder. You can do so by just adding a line in one of the YAML files
    which checks if your new feature compiles correctly.
- - Sometimes I will let pull requests linger because I'm not 100% sure about them. Please feel free to ping
-   me after some time.

docker/Dockerfile

@@ -34,10 +34,11 @@ RUN \
         python3-wheel=0.38.4-2 \
         iputils-ping=3:20221126-1 \
         git=1:2.39.2-1.1 \
-        curl=7.88.1-10+deb12u4 \
+        curl=7.88.1-10+deb12u5 \
         openssh-client=1:9.2p1-2+deb12u1 \
         python3-cffi=1.15.1-5 \
         libcairo2=1.16.0-7 \
+        libmagic1=1:5.44-3 \
         patch=2.7.6-7; \
     if [ "$TARGETARCH$TARGETVARIANT" = "armv7" ]; then \
         apt-get install -y --no-install-recommends \
@@ -48,6 +49,8 @@ RUN \
           libfreetype-dev=2.12.1+dfsg-5 \
           libssl-dev=3.0.11-1~deb12u2 \
           libffi-dev=3.4.4-1 \
+          libopenjp2-7=2.5.0-2 \
+          libtiff6=4.5.0-6+deb12u1 \
           cargo=0.66.0+ds1-1 \
           pkg-config=1.8.1-1 \
           gcc-arm-linux-gnueabihf=4:12.2.0-3; \
@@ -68,7 +71,7 @@ ENV \
 # See: https://unix.stackexchange.com/questions/553743/correct-way-to-add-lib-ld-linux-so-3-in-debian
 RUN \
     if [ "$TARGETARCH$TARGETVARIANT" = "armv7" ]; then \
-        ln -s /lib/arm-linux-gnueabihf/ld-linux.so.3 /lib/ld-linux.so.3; \
+        ln -s /lib/arm-linux-gnueabihf/ld-linux-armhf.so.3 /lib/ld-linux.so.3; \
     fi
 
 RUN \

docker/generate_tags.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
 import re
-import os
 import argparse
-import json
 
 CHANNEL_DEV = "dev"
 CHANNEL_BETA = "beta"
 CHANNEL_RELEASE = "release"
 
+GHCR = "ghcr"
+DOCKERHUB = "dockerhub"
+
 parser = argparse.ArgumentParser()
 parser.add_argument(
     "--tag",
@@ -21,21 +22,31 @@ parser.add_argument(
     required=True,
     help="The suffix of the tag.",
 )
+parser.add_argument(
+    "--registry",
+    type=str,
+    choices=[GHCR, DOCKERHUB],
+    required=False,
+    action="append",
+    help="The registry to build tags for.",
+)
 
 
 def main():
     args = parser.parse_args()
 
     # detect channel from tag
-    match = re.match(r"^(\d+\.\d+)(?:\.\d+)?(b\d+)?$", args.tag)
+    match = re.match(r"^(\d+\.\d+)(?:\.\d+)(?:(b\d+)|(-dev\d+))?$", args.tag)
     major_minor_version = None
-    if match is None:
+    if match is None:  # eg 2023.12.0-dev20231109-testbranch
+        channel = None  # Ran with custom tag for a branch etc
+    elif match.group(3) is not None:  # eg 2023.12.0-dev20231109
         channel = CHANNEL_DEV
-    elif match.group(2) is None:
+    elif match.group(2) is not None:  # eg 2023.12.0b1
+        channel = CHANNEL_BETA
+    else:  # eg 2023.12.0
         major_minor_version = match.group(1)
         channel = CHANNEL_RELEASE
-    else:
-        channel = CHANNEL_BETA
 
     tags_to_push = [args.tag]
     if channel == CHANNEL_DEV:
@@ -53,15 +64,28 @@ def main():
 
     suffix = f"-{args.suffix}" if args.suffix else ""
 
-    with open(os.environ["GITHUB_OUTPUT"], "w") as f:
-        print(f"channel={channel}", file=f)
-        print(f"image=esphome/esphome{suffix}", file=f)
-        full_tags = []
+    image_name = f"esphome/esphome{suffix}"
 
-        for tag in tags_to_push:
-            full_tags += [f"ghcr.io/esphome/esphome{suffix}:{tag}"]
-            full_tags += [f"esphome/esphome{suffix}:{tag}"]
-        print(f"tags={','.join(full_tags)}", file=f)
+    print(f"channel={channel}")
+
+    if args.registry is None:
+        args.registry = [GHCR, DOCKERHUB]
+    elif len(args.registry) == 1:
+        if GHCR in args.registry:
+            print(f"image=ghcr.io/{image_name}")
+        if DOCKERHUB in args.registry:
+            print(f"image=docker.io/{image_name}")
+
+    print(f"image_name={image_name}")
+
+    full_tags = []
+
+    for tag in tags_to_push:
+        if GHCR in args.registry:
+            full_tags += [f"ghcr.io/{image_name}:{tag}"]
+        if DOCKERHUB in args.registry:
+            full_tags += [f"docker.io/{image_name}:{tag}"]
+    print(f"tags={','.join(full_tags)}")
 
 
 if __name__ == "__main__":

esphome/__main__.py

@@ -12,7 +12,7 @@ import argcomplete
 
 from esphome import const, writer, yaml_util
 import esphome.codegen as cg
-from esphome.config import iter_components, read_config, strip_default_ids
+from esphome.config import iter_component_configs, read_config, strip_default_ids
 from esphome.const import (
     ALLOWED_NAME_CHARS,
     CONF_BAUD_RATE,
@@ -196,7 +196,7 @@ def write_cpp(config):
 def generate_cpp_contents(config):
     _LOGGER.info("Generating C++ source...")
 
-    for name, component, conf in iter_components(CORE.config):
+    for name, component, conf in iter_component_configs(CORE.config):
         if component.to_code is not None:
             coro = wrap_to_code(name, component)
             CORE.add_job(coro, conf)
@@ -389,7 +389,8 @@ def command_config(args, config):
         output = re.sub(
             r"(password|key|psk|ssid)\: (.+)", r"\1: \\033[5m\2\\033[6m", output
         )
-    safe_print(output)
+    if not CORE.quiet:
+        safe_print(output)
     _LOGGER.info("Configuration is valid!")
     return 0
 

esphome/components/a01nyub/a01nyub.cpp

@@ -8,50 +8,37 @@ namespace esphome {
 namespace a01nyub {
 
 static const char *const TAG = "a01nyub.sensor";
-static const uint8_t MAX_DATA_LENGTH_BYTES = 4;
 
 void A01nyubComponent::loop() {
   uint8_t data;
   while (this->available() > 0) {
-    if (this->read_byte(&data)) {
-      buffer_.push_back(data);
+    this->read_byte(&data);
+    if (this->buffer_.empty() && (data != 0xff))
+      continue;
+    buffer_.push_back(data);
+    if (this->buffer_.size() == 4)
       this->check_buffer_();
-    }
   }
 }
 
 void A01nyubComponent::check_buffer_() {
-  if (this->buffer_.size() >= MAX_DATA_LENGTH_BYTES) {
-    size_t i;
-    for (i = 0; i < this->buffer_.size(); i++) {
-      // Look for the first packet
-      if (this->buffer_[i] == 0xFF) {
-        if (i + 1 + 3 < this->buffer_.size()) {  // Packet is not complete
-          return;                                // Wait for completion
-        }
-
-        uint8_t checksum = (this->buffer_[i] + this->buffer_[i + 1] + this->buffer_[i + 2]) & 0xFF;
-        if (this->buffer_[i + 3] == checksum) {
-          float distance = (this->buffer_[i + 1] << 8) + this->buffer_[i + 2];
-          if (distance > 280) {
-            float meters = distance / 1000.0;
-            ESP_LOGV(TAG, "Distance from sensor: %f mm, %f m", distance, meters);
-            this->publish_state(meters);
-          } else {
-            ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
-          }
-        }
-        break;
-      }
+  uint8_t checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
+  if (this->buffer_[3] == checksum) {
+    float distance = (this->buffer_[1] << 8) + this->buffer_[2];
+    if (distance > 280) {
+      float meters = distance / 1000.0;
+      ESP_LOGV(TAG, "Distance from sensor: %f mm, %f m", distance, meters);
+      this->publish_state(meters);
+    } else {
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
     }
-    this->buffer_.clear();
+  } else {
+    ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);
   }
+  this->buffer_.clear();
 }
 
-void A01nyubComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "A01nyub Sensor:");
-  LOG_SENSOR("  ", "Distance", this);
-}
+void A01nyubComponent::dump_config() { LOG_SENSOR("", "A01nyub Sensor", this); }
 
 }  // namespace a01nyub
 }  // namespace esphome

esphome/components/a02yyuw/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@TH-Braemer"]

esphome/components/a02yyuw/a02yyuw.cpp

@@ -0,0 +1,43 @@
+// Datasheet https://wiki.dfrobot.com/_A02YYUW_Waterproof_Ultrasonic_Sensor_SKU_SEN0311
+
+#include "a02yyuw.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace a02yyuw {
+
+static const char *const TAG = "a02yyuw.sensor";
+
+void A02yyuwComponent::loop() {
+  uint8_t data;
+  while (this->available() > 0) {
+    this->read_byte(&data);
+    if (this->buffer_.empty() && (data != 0xff))
+      continue;
+    buffer_.push_back(data);
+    if (this->buffer_.size() == 4)
+      this->check_buffer_();
+  }
+}
+
+void A02yyuwComponent::check_buffer_() {
+  uint8_t checksum = this->buffer_[0] + this->buffer_[1] + this->buffer_[2];
+  if (this->buffer_[3] == checksum) {
+    float distance = (this->buffer_[1] << 8) + this->buffer_[2];
+    if (distance > 30) {
+      ESP_LOGV(TAG, "Distance from sensor: %f mm", distance);
+      this->publish_state(distance);
+    } else {
+      ESP_LOGW(TAG, "Invalid data read from sensor: %s", format_hex_pretty(this->buffer_).c_str());
+    }
+  } else {
+    ESP_LOGW(TAG, "checksum failed: %02x != %02x", checksum, this->buffer_[3]);
+  }
+  this->buffer_.clear();
+}
+
+void A02yyuwComponent::dump_config() { LOG_SENSOR("", "A02yyuw Sensor", this); }
+
+}  // namespace a02yyuw
+}  // namespace esphome

esphome/components/a02yyuw/a02yyuw.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/uart/uart.h"
+
+namespace esphome {
+namespace a02yyuw {
+
+class A02yyuwComponent : public sensor::Sensor, public Component, public uart::UARTDevice {
+ public:
+  // Nothing really public.
+
+  // ========== INTERNAL METHODS ==========
+  void loop() override;
+  void dump_config() override;
+
+ protected:
+  void check_buffer_();
+
+  std::vector<uint8_t> buffer_;
+};
+
+}  // namespace a02yyuw
+}  // namespace esphome

esphome/components/a02yyuw/sensor.py

@@ -0,0 +1,41 @@
+import esphome.codegen as cg
+from esphome.components import sensor, uart
+from esphome.const import (
+    STATE_CLASS_MEASUREMENT,
+    ICON_ARROW_EXPAND_VERTICAL,
+    DEVICE_CLASS_DISTANCE,
+)
+
+CODEOWNERS = ["@TH-Braemer"]
+DEPENDENCIES = ["uart"]
+UNIT_MILLIMETERS = "mm"
+
+a02yyuw_ns = cg.esphome_ns.namespace("a02yyuw")
+A02yyuwComponent = a02yyuw_ns.class_(
+    "A02yyuwComponent", sensor.Sensor, cg.Component, uart.UARTDevice
+)
+
+CONFIG_SCHEMA = sensor.sensor_schema(
+    A02yyuwComponent,
+    unit_of_measurement=UNIT_MILLIMETERS,
+    icon=ICON_ARROW_EXPAND_VERTICAL,
+    accuracy_decimals=0,
+    state_class=STATE_CLASS_MEASUREMENT,
+    device_class=DEVICE_CLASS_DISTANCE,
+).extend(uart.UART_DEVICE_SCHEMA)
+
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "a02yyuw",
+    baud_rate=9600,
+    require_tx=False,
+    require_rx=True,
+    data_bits=8,
+    parity=None,
+    stop_bits=1,
+)
+
+
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)

esphome/components/adc/__init__.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.const import CONF_ANALOG, CONF_INPUT
+from esphome.const import CONF_ANALOG, CONF_INPUT, CONF_NUMBER
 
 from esphome.core import CORE
 from esphome.components.esp32 import get_esp32_variant
@@ -152,7 +152,8 @@ def validate_adc_pin(value):
         return cv.only_on_rp2040("TEMPERATURE")
 
     if CORE.is_esp32:
-        value = pins.internal_gpio_input_pin_number(value)
+        conf = pins.internal_gpio_input_pin_schema(value)
+        value = conf[CONF_NUMBER]
         variant = get_esp32_variant()
         if (
             variant not in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL
@@ -166,24 +167,23 @@ def validate_adc_pin(value):
         ):
             raise cv.Invalid(f"{variant} doesn't support ADC on this pin")
 
-        return pins.internal_gpio_input_pin_schema(value)
+        return conf
 
     if CORE.is_esp8266:
-        value = pins.internal_gpio_pin_number({CONF_ANALOG: True, CONF_INPUT: True})(
-            value
-        )
-
-        if value != 17:  # A0
-            raise cv.Invalid("ESP8266: Only pin A0 (GPIO17) supports ADC")
-        return pins.gpio_pin_schema(
+        conf = pins.gpio_pin_schema(
             {CONF_ANALOG: True, CONF_INPUT: True}, internal=True
         )(value)
 
+        if conf[CONF_NUMBER] != 17:  # A0
+            raise cv.Invalid("ESP8266: Only pin A0 (GPIO17) supports ADC")
+        return conf
+
     if CORE.is_rp2040:
-        value = pins.internal_gpio_input_pin_number(value)
-        if value not in (26, 27, 28, 29):
+        conf = pins.internal_gpio_input_pin_schema(value)
+        number = conf[CONF_NUMBER]
+        if number not in (26, 27, 28, 29):
             raise cv.Invalid("RP2040: Only pins 26, 27, 28 and 29 support ADC")
-        return pins.internal_gpio_input_pin_schema(value)
+        return conf
 
     if CORE.is_libretiny:
         return pins.gpio_pin_schema(

esphome/components/addressable_light/addressable_light_display.h

@@ -10,7 +10,7 @@
 namespace esphome {
 namespace addressable_light {
 
-class AddressableLightDisplay : public display::DisplayBuffer, public PollingComponent {
+class AddressableLightDisplay : public display::DisplayBuffer {
  public:
   light::AddressableLight *get_light() const { return this->light_; }
 

esphome/components/addressable_light/display.py

@@ -45,7 +45,6 @@ async def to_code(config):
     cg.add(var.set_height(config[CONF_HEIGHT]))
     cg.add(var.set_light(wrapped_light))
 
-    await cg.register_component(var, config)
     await display.register_display(var, config)
 
     if pixel_mapper := config.get(CONF_PIXEL_MAPPER):

esphome/components/aht10/aht10.cpp

@@ -21,36 +21,49 @@ namespace esphome {
 namespace aht10 {
 
 static const char *const TAG = "aht10";
-static const uint8_t AHT10_CALIBRATE_CMD[] = {0xE1};
+static const size_t SIZE_CALIBRATE_CMD = 3;
+static const uint8_t AHT10_CALIBRATE_CMD[] = {0xE1, 0x08, 0x00};
+static const uint8_t AHT20_CALIBRATE_CMD[] = {0xBE, 0x08, 0x00};
 static const uint8_t AHT10_MEASURE_CMD[] = {0xAC, 0x33, 0x00};
 static const uint8_t AHT10_DEFAULT_DELAY = 5;    // ms, for calibration and temperature measurement
 static const uint8_t AHT10_HUMIDITY_DELAY = 30;  // ms
 static const uint8_t AHT10_ATTEMPTS = 3;         // safety margin, normally 3 attempts are enough: 3*30=90ms
+static const uint8_t AHT10_CAL_ATTEMPTS = 10;
+static const uint8_t AHT10_STATUS_BUSY = 0x80;
 
 void AHT10Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up AHT10...");
+  const uint8_t *calibrate_cmd;
+  switch (this->variant_) {
+    case AHT10Variant::AHT20:
+      calibrate_cmd = AHT20_CALIBRATE_CMD;
+      ESP_LOGCONFIG(TAG, "Setting up AHT20");
+      break;
+    case AHT10Variant::AHT10:
+    default:
+      calibrate_cmd = AHT10_CALIBRATE_CMD;
+      ESP_LOGCONFIG(TAG, "Setting up AHT10");
+  }
 
-  if (!this->write_bytes(0, AHT10_CALIBRATE_CMD, sizeof(AHT10_CALIBRATE_CMD))) {
+  if (this->write(calibrate_cmd, SIZE_CALIBRATE_CMD) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, "Communication with AHT10 failed!");
     this->mark_failed();
     return;
   }
-  uint8_t data = 0;
-  if (this->write(&data, 1) != i2c::ERROR_OK) {
-    ESP_LOGD(TAG, "Communication with AHT10 failed!");
-    this->mark_failed();
-    return;
-  }
-  delay(AHT10_DEFAULT_DELAY);
-  if (this->read(&data, 1) != i2c::ERROR_OK) {
-    ESP_LOGD(TAG, "Communication with AHT10 failed!");
-    this->mark_failed();
-    return;
-  }
-  if (this->read(&data, 1) != i2c::ERROR_OK) {
-    ESP_LOGD(TAG, "Communication with AHT10 failed!");
-    this->mark_failed();
-    return;
+  uint8_t data = AHT10_STATUS_BUSY;
+  int cal_attempts = 0;
+  while (data & AHT10_STATUS_BUSY) {
+    delay(AHT10_DEFAULT_DELAY);
+    if (this->read(&data, 1) != i2c::ERROR_OK) {
+      ESP_LOGE(TAG, "Communication with AHT10 failed!");
+      this->mark_failed();
+      return;
+    }
+    ++cal_attempts;
+    if (cal_attempts > AHT10_CAL_ATTEMPTS) {
+      ESP_LOGE(TAG, "AHT10 calibration timed out!");
+      this->mark_failed();
+      return;
+    }
   }
   if ((data & 0x68) != 0x08) {  // Bit[6:5] = 0b00, NORMAL mode and Bit[3] = 0b1, CALIBRATED
     ESP_LOGE(TAG, "AHT10 calibration failed!");
@@ -62,7 +75,7 @@ void AHT10Component::setup() {
 }
 
 void AHT10Component::update() {
-  if (!this->write_bytes(0, AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD))) {
+  if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, "Communication with AHT10 failed!");
     this->status_set_warning();
     return;
@@ -89,7 +102,7 @@ void AHT10Component::update() {
         break;
       } else {
         ESP_LOGD(TAG, "ATH10 Unrealistic humidity (0x0), retrying...");
-        if (!this->write_bytes(0, AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD))) {
+        if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
           ESP_LOGE(TAG, "Communication with AHT10 failed!");
           this->status_set_warning();
           return;

esphome/components/aht10/aht10.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
@@ -7,12 +9,15 @@
 namespace esphome {
 namespace aht10 {
 
+enum AHT10Variant { AHT10, AHT20 };
+
 class AHT10Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void update() override;
   void dump_config() override;
   float get_setup_priority() const override;
+  void set_variant(AHT10Variant variant) { this->variant_ = variant; }
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
@@ -20,6 +25,7 @@ class AHT10Component : public PollingComponent, public i2c::I2CDevice {
  protected:
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};
+  AHT10Variant variant_{};
 };
 
 }  // namespace aht10

esphome/components/aht10/sensor.py

@@ -10,6 +10,7 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     UNIT_CELSIUS,
     UNIT_PERCENT,
+    CONF_VARIANT,
 )
 
 DEPENDENCIES = ["i2c"]
@@ -17,6 +18,12 @@ DEPENDENCIES = ["i2c"]
 aht10_ns = cg.esphome_ns.namespace("aht10")
 AHT10Component = aht10_ns.class_("AHT10Component", cg.PollingComponent, i2c.I2CDevice)
 
+AHT10Variant = aht10_ns.enum("AHT10Variant")
+AHT10_VARIANTS = {
+    "AHT10": AHT10Variant.AHT10,
+    "AHT20": AHT10Variant.AHT20,
+}
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -33,6 +40,9 @@ CONFIG_SCHEMA = (
                 device_class=DEVICE_CLASS_HUMIDITY,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_VARIANT, default="AHT10"): cv.enum(
+                AHT10_VARIANTS, upper=True
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -44,6 +54,7 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
+    cg.add(var.set_variant(config[CONF_VARIANT]))
 
     if temperature := config.get(CONF_TEMPERATURE):
         sens = await sensor.new_sensor(temperature)

esphome/components/api/api.proto

@@ -365,6 +365,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10;
   EntityCategory entity_category = 11;
+  repeated string supported_preset_modes = 12;
 }
 enum FanSpeed {
   FAN_SPEED_LOW = 0;
@@ -387,6 +388,7 @@ message FanStateResponse {
   FanSpeed speed = 4 [deprecated = true];
   FanDirection direction = 5;
   int32 speed_level = 6;
+  string preset_mode = 7;
 }
 message FanCommandRequest {
   option (id) = 31;
@@ -405,6 +407,8 @@ message FanCommandRequest {
   FanDirection direction = 9;
   bool has_speed_level = 10;
   int32 speed_level = 11;
+  bool has_preset_mode = 12;
+  string preset_mode = 13;
 }
 
 // ==================== LIGHT ====================
@@ -855,6 +859,10 @@ message ListEntitiesClimateResponse {
   string icon = 19;
   EntityCategory entity_category = 20;
   float visual_current_temperature_step = 21;
+  bool supports_current_humidity = 22;
+  bool supports_target_humidity = 23;
+  float visual_min_humidity = 24;
+  float visual_max_humidity = 25;
 }
 message ClimateStateResponse {
   option (id) = 47;
@@ -875,6 +883,8 @@ message ClimateStateResponse {
   string custom_fan_mode = 11;
   ClimatePreset preset = 12;
   string custom_preset = 13;
+  float current_humidity = 14;
+  float target_humidity = 15;
 }
 message ClimateCommandRequest {
   option (id) = 48;
@@ -903,6 +913,8 @@ message ClimateCommandRequest {
   ClimatePreset preset = 19;
   bool has_custom_preset = 20;
   string custom_preset = 21;
+  bool has_target_humidity = 22;
+  float target_humidity = 23;
 }
 
 // ==================== NUMBER ====================

esphome/components/api/api_connection.cpp

@@ -118,7 +118,9 @@ void APIConnection::loop() {
   this->list_entities_iterator_.advance();
   this->initial_state_iterator_.advance();
 
-  const uint32_t keepalive = 60000;
+  static uint32_t keepalive = 60000;
+  static uint8_t max_ping_retries = 60;
+  static uint16_t ping_retry_interval = 1000;
   const uint32_t now = millis();
   if (this->sent_ping_) {
     // Disconnect if not responded within 2.5*keepalive
@@ -126,10 +128,24 @@ void APIConnection::loop() {
       on_fatal_error();
       ESP_LOGW(TAG, "%s didn't respond to ping request in time. Disconnecting...", this->client_combined_info_.c_str());
     }
-  } else if (now - this->last_traffic_ > keepalive) {
+  } else if (now - this->last_traffic_ > keepalive && now > this->next_ping_retry_) {
     ESP_LOGVV(TAG, "Sending keepalive PING...");
-    this->sent_ping_ = true;
-    this->send_ping_request(PingRequest());
+    this->sent_ping_ = this->send_ping_request(PingRequest());
+    if (!this->sent_ping_) {
+      this->next_ping_retry_ = now + ping_retry_interval;
+      this->ping_retries_++;
+      if (this->ping_retries_ >= max_ping_retries) {
+        on_fatal_error();
+        ESP_LOGE(TAG, "%s: Sending keepalive failed %d time(s). Disconnecting...", this->client_combined_info_.c_str(),
+                 this->ping_retries_);
+      } else if (this->ping_retries_ >= 10) {
+        ESP_LOGW(TAG, "%s: Sending keepalive failed %d time(s), will retry in %d ms",
+                 this->client_combined_info_.c_str(), this->ping_retries_, ping_retry_interval);
+      } else {
+        ESP_LOGD(TAG, "%s: Sending keepalive failed %d time(s), will retry in %d ms",
+                 this->client_combined_info_.c_str(), this->ping_retries_, ping_retry_interval);
+      }
+    }
   }
 
 #ifdef USE_ESP32_CAMERA
@@ -293,6 +309,8 @@ bool APIConnection::send_fan_state(fan::Fan *fan) {
   }
   if (traits.supports_direction())
     resp.direction = static_cast<enums::FanDirection>(fan->direction);
+  if (traits.supports_preset_modes())
+    resp.preset_mode = fan->preset_mode;
   return this->send_fan_state_response(resp);
 }
 bool APIConnection::send_fan_info(fan::Fan *fan) {
@@ -307,6 +325,8 @@ bool APIConnection::send_fan_info(fan::Fan *fan) {
   msg.supports_speed = traits.supports_speed();
   msg.supports_direction = traits.supports_direction();
   msg.supported_speed_count = traits.supported_speed_count();
+  for (auto const &preset : traits.supported_preset_modes())
+    msg.supported_preset_modes.push_back(preset);
   msg.disabled_by_default = fan->is_disabled_by_default();
   msg.icon = fan->get_icon();
   msg.entity_category = static_cast<enums::EntityCategory>(fan->get_entity_category());
@@ -328,6 +348,8 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   }
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
+  if (msg.has_preset_mode)
+    call.set_preset_mode(msg.preset_mode);
   call.perform();
 }
 #endif
@@ -554,6 +576,10 @@ bool APIConnection::send_climate_state(climate::Climate *climate) {
     resp.custom_preset = climate->custom_preset.value();
   if (traits.get_supports_swing_modes())
     resp.swing_mode = static_cast<enums::ClimateSwingMode>(climate->swing_mode);
+  if (traits.get_supports_current_humidity())
+    resp.current_humidity = climate->current_humidity;
+  if (traits.get_supports_target_humidity())
+    resp.target_humidity = climate->target_humidity;
   return this->send_climate_state_response(resp);
 }
 bool APIConnection::send_climate_info(climate::Climate *climate) {
@@ -570,7 +596,9 @@ bool APIConnection::send_climate_info(climate::Climate *climate) {
   msg.entity_category = static_cast<enums::EntityCategory>(climate->get_entity_category());
 
   msg.supports_current_temperature = traits.get_supports_current_temperature();
+  msg.supports_current_humidity = traits.get_supports_current_humidity();
   msg.supports_two_point_target_temperature = traits.get_supports_two_point_target_temperature();
+  msg.supports_target_humidity = traits.get_supports_target_humidity();
 
   for (auto mode : traits.get_supported_modes())
     msg.supported_modes.push_back(static_cast<enums::ClimateMode>(mode));
@@ -579,6 +607,8 @@ bool APIConnection::send_climate_info(climate::Climate *climate) {
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_target_temperature_step = traits.get_visual_target_temperature_step();
   msg.visual_current_temperature_step = traits.get_visual_current_temperature_step();
+  msg.visual_min_humidity = traits.get_visual_min_humidity();
+  msg.visual_max_humidity = traits.get_visual_max_humidity();
 
   msg.legacy_supports_away = traits.supports_preset(climate::CLIMATE_PRESET_AWAY);
   msg.supports_action = traits.get_supports_action();
@@ -609,6 +639,8 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
     call.set_target_temperature_low(msg.target_temperature_low);
   if (msg.has_target_temperature_high)
     call.set_target_temperature_high(msg.target_temperature_high);
+  if (msg.has_target_humidity)
+    call.set_target_humidity(msg.target_humidity);
   if (msg.has_fan_mode)
     call.set_fan_mode(static_cast<climate::ClimateFanMode>(msg.fan_mode));
   if (msg.has_custom_fan_mode)

esphome/components/api/api_connection.h

@@ -140,6 +140,7 @@ class APIConnection : public APIServerConnection {
   void on_disconnect_response(const DisconnectResponse &value) override;
   void on_ping_response(const PingResponse &value) override {
     // we initiated ping
+    this->ping_retries_ = 0;
     this->sent_ping_ = false;
   }
   void on_home_assistant_state_response(const HomeAssistantStateResponse &msg) override;
@@ -217,6 +218,8 @@ class APIConnection : public APIServerConnection {
   bool state_subscription_{false};
   int log_subscription_{ESPHOME_LOG_LEVEL_NONE};
   uint32_t last_traffic_;
+  uint32_t next_ping_retry_{0};
+  uint8_t ping_retries_{0};
   bool sent_ping_{false};
   bool service_call_subscription_{false};
   bool next_close_ = false;

esphome/components/api/api_pb2.cpp

@@ -1375,6 +1375,10 @@ bool ListEntitiesFanResponse::decode_length(uint32_t field_id, ProtoLengthDelimi
       this->icon = value.as_string();
       return true;
     }
+    case 12: {
+      this->supported_preset_modes.push_back(value.as_string());
+      return true;
+    }
     default:
       return false;
   }
@@ -1401,6 +1405,9 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(9, this->disabled_by_default);
   buffer.encode_string(10, this->icon);
   buffer.encode_enum<enums::EntityCategory>(11, this->entity_category);
+  for (auto &it : this->supported_preset_modes) {
+    buffer.encode_string(12, it, true);
+  }
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesFanResponse::dump_to(std::string &out) const {
@@ -1451,6 +1458,12 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
   out.append("  entity_category: ");
   out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
   out.append("\n");
+
+  for (const auto &it : this->supported_preset_modes) {
+    out.append("  supported_preset_modes: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
   out.append("}");
 }
 #endif
@@ -1480,6 +1493,16 @@ bool FanStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       return false;
   }
 }
+bool FanStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 7: {
+      this->preset_mode = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 bool FanStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
     case 1: {
@@ -1497,6 +1520,7 @@ void FanStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::FanSpeed>(4, this->speed);
   buffer.encode_enum<enums::FanDirection>(5, this->direction);
   buffer.encode_int32(6, this->speed_level);
+  buffer.encode_string(7, this->preset_mode);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanStateResponse::dump_to(std::string &out) const {
@@ -1527,6 +1551,10 @@ void FanStateResponse::dump_to(std::string &out) const {
   sprintf(buffer, "%" PRId32, this->speed_level);
   out.append(buffer);
   out.append("\n");
+
+  out.append("  preset_mode: ");
+  out.append("'").append(this->preset_mode).append("'");
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -1572,6 +1600,20 @@ bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->speed_level = value.as_int32();
       return true;
     }
+    case 12: {
+      this->has_preset_mode = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool FanCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 13: {
+      this->preset_mode = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -1598,6 +1640,8 @@ void FanCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::FanDirection>(9, this->direction);
   buffer.encode_bool(10, this->has_speed_level);
   buffer.encode_int32(11, this->speed_level);
+  buffer.encode_bool(12, this->has_preset_mode);
+  buffer.encode_string(13, this->preset_mode);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void FanCommandRequest::dump_to(std::string &out) const {
@@ -1648,6 +1692,14 @@ void FanCommandRequest::dump_to(std::string &out) const {
   sprintf(buffer, "%" PRId32, this->speed_level);
   out.append(buffer);
   out.append("\n");
+
+  out.append("  has_preset_mode: ");
+  out.append(YESNO(this->has_preset_mode));
+  out.append("\n");
+
+  out.append("  preset_mode: ");
+  out.append("'").append(this->preset_mode).append("'");
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -3559,6 +3611,14 @@ bool ListEntitiesClimateResponse::decode_varint(uint32_t field_id, ProtoVarInt v
       this->entity_category = value.as_enum<enums::EntityCategory>();
       return true;
     }
+    case 22: {
+      this->supports_current_humidity = value.as_bool();
+      return true;
+    }
+    case 23: {
+      this->supports_target_humidity = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -3615,6 +3675,14 @@ bool ListEntitiesClimateResponse::decode_32bit(uint32_t field_id, Proto32Bit val
       this->visual_current_temperature_step = value.as_float();
       return true;
     }
+    case 24: {
+      this->visual_min_humidity = value.as_float();
+      return true;
+    }
+    case 25: {
+      this->visual_max_humidity = value.as_float();
+      return true;
+    }
     default:
       return false;
   }
@@ -3653,6 +3721,10 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(19, this->icon);
   buffer.encode_enum<enums::EntityCategory>(20, this->entity_category);
   buffer.encode_float(21, this->visual_current_temperature_step);
+  buffer.encode_bool(22, this->supports_current_humidity);
+  buffer.encode_bool(23, this->supports_target_humidity);
+  buffer.encode_float(24, this->visual_min_humidity);
+  buffer.encode_float(25, this->visual_max_humidity);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesClimateResponse::dump_to(std::string &out) const {
@@ -3758,6 +3830,24 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   sprintf(buffer, "%g", this->visual_current_temperature_step);
   out.append(buffer);
   out.append("\n");
+
+  out.append("  supports_current_humidity: ");
+  out.append(YESNO(this->supports_current_humidity));
+  out.append("\n");
+
+  out.append("  supports_target_humidity: ");
+  out.append(YESNO(this->supports_target_humidity));
+  out.append("\n");
+
+  out.append("  visual_min_humidity: ");
+  sprintf(buffer, "%g", this->visual_min_humidity);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  visual_max_humidity: ");
+  sprintf(buffer, "%g", this->visual_max_humidity);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -3827,6 +3917,14 @@ bool ClimateStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->target_temperature_high = value.as_float();
       return true;
     }
+    case 14: {
+      this->current_humidity = value.as_float();
+      return true;
+    }
+    case 15: {
+      this->target_humidity = value.as_float();
+      return true;
+    }
     default:
       return false;
   }
@@ -3845,6 +3943,8 @@ void ClimateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(11, this->custom_fan_mode);
   buffer.encode_enum<enums::ClimatePreset>(12, this->preset);
   buffer.encode_string(13, this->custom_preset);
+  buffer.encode_float(14, this->current_humidity);
+  buffer.encode_float(15, this->target_humidity);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateStateResponse::dump_to(std::string &out) const {
@@ -3906,6 +4006,16 @@ void ClimateStateResponse::dump_to(std::string &out) const {
   out.append("  custom_preset: ");
   out.append("'").append(this->custom_preset).append("'");
   out.append("\n");
+
+  out.append("  current_humidity: ");
+  sprintf(buffer, "%g", this->current_humidity);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  target_humidity: ");
+  sprintf(buffer, "%g", this->target_humidity);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -3971,6 +4081,10 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
       this->has_custom_preset = value.as_bool();
       return true;
     }
+    case 22: {
+      this->has_target_humidity = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -4007,6 +4121,10 @@ bool ClimateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->target_temperature_high = value.as_float();
       return true;
     }
+    case 23: {
+      this->target_humidity = value.as_float();
+      return true;
+    }
     default:
       return false;
   }
@@ -4033,6 +4151,8 @@ void ClimateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::ClimatePreset>(19, this->preset);
   buffer.encode_bool(20, this->has_custom_preset);
   buffer.encode_string(21, this->custom_preset);
+  buffer.encode_bool(22, this->has_target_humidity);
+  buffer.encode_float(23, this->target_humidity);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateCommandRequest::dump_to(std::string &out) const {
@@ -4125,6 +4245,15 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   out.append("  custom_preset: ");
   out.append("'").append(this->custom_preset).append("'");
   out.append("\n");
+
+  out.append("  has_target_humidity: ");
+  out.append(YESNO(this->has_target_humidity));
+  out.append("\n");
+
+  out.append("  target_humidity: ");
+  sprintf(buffer, "%g", this->target_humidity);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
 #endif

esphome/components/api/api_pb2.h

@@ -472,6 +472,7 @@ class ListEntitiesFanResponse : public ProtoMessage {
   bool disabled_by_default{false};
   std::string icon{};
   enums::EntityCategory entity_category{};
+  std::vector<std::string> supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -490,6 +491,7 @@ class FanStateResponse : public ProtoMessage {
   enums::FanSpeed speed{};
   enums::FanDirection direction{};
   int32_t speed_level{0};
+  std::string preset_mode{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -497,6 +499,7 @@ class FanStateResponse : public ProtoMessage {
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class FanCommandRequest : public ProtoMessage {
@@ -512,6 +515,8 @@ class FanCommandRequest : public ProtoMessage {
   enums::FanDirection direction{};
   bool has_speed_level{false};
   int32_t speed_level{0};
+  bool has_preset_mode{false};
+  std::string preset_mode{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -519,6 +524,7 @@ class FanCommandRequest : public ProtoMessage {
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class ListEntitiesLightResponse : public ProtoMessage {
@@ -979,6 +985,10 @@ class ListEntitiesClimateResponse : public ProtoMessage {
   std::string icon{};
   enums::EntityCategory entity_category{};
   float visual_current_temperature_step{0.0f};
+  bool supports_current_humidity{false};
+  bool supports_target_humidity{false};
+  float visual_min_humidity{0.0f};
+  float visual_max_humidity{0.0f};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1004,6 +1014,8 @@ class ClimateStateResponse : public ProtoMessage {
   std::string custom_fan_mode{};
   enums::ClimatePreset preset{};
   std::string custom_preset{};
+  float current_humidity{0.0f};
+  float target_humidity{0.0f};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1037,6 +1049,8 @@ class ClimateCommandRequest : public ProtoMessage {
   enums::ClimatePreset preset{};
   bool has_custom_preset{false};
   std::string custom_preset{};
+  bool has_target_humidity{false};
+  float target_humidity{0.0f};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;

esphome/components/api/api_server.cpp

@@ -319,7 +319,7 @@ void APIServer::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeo
 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
   for (auto &client : this->clients_) {
-    if (!client->remove_ && client->connection_state_ == APIConnection::ConnectionState::CONNECTED)
+    if (!client->remove_ && client->is_authenticated())
       client->send_time_request();
   }
 }

esphome/components/api/client.py

@@ -8,7 +8,6 @@ from typing import Any
 from aioesphomeapi import APIClient
 from aioesphomeapi.api_pb2 import SubscribeLogsResponse
 from aioesphomeapi.log_runner import async_run
-from zeroconf.asyncio import AsyncZeroconf
 
 from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
 from esphome.core import CORE
@@ -18,24 +17,22 @@ from . import CONF_ENCRYPTION
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_run_logs(config, address):
+async def async_run_logs(config: dict[str, Any], address: str) -> None:
     """Run the logs command in the event loop."""
     conf = config["api"]
+    name = config["esphome"]["name"]
     port: int = int(conf[CONF_PORT])
     password: str = conf[CONF_PASSWORD]
     noise_psk: str | None = None
     if CONF_ENCRYPTION in conf:
         noise_psk = conf[CONF_ENCRYPTION][CONF_KEY]
     _LOGGER.info("Starting log output from %s using esphome API", address)
-    aiozc = AsyncZeroconf()
-
     cli = APIClient(
         address,
         port,
         password,
         client_info=f"ESPHome Logs {__version__}",
         noise_psk=noise_psk,
-        zeroconf_instance=aiozc.zeroconf,
     )
     dashboard = CORE.dashboard
 
@@ -48,12 +45,10 @@ async def async_run_logs(config, address):
             text = text.replace("\033", "\\033")
         print(f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]{text}")
 
-    stop = await async_run(cli, on_log, aio_zeroconf_instance=aiozc)
+    stop = await async_run(cli, on_log, name=name)
     try:
-        while True:
-            await asyncio.sleep(60)
+        await asyncio.Event().wait()
     finally:
-        await aiozc.async_close()
         await stop()
 
 

esphome/components/api/proto.h

@@ -160,8 +160,7 @@ class ProtoWriteBuffer {
     this->encode_field_raw(field_id, 2);
     this->encode_varint_raw(len);
     auto *data = reinterpret_cast<const uint8_t *>(string);
-    for (size_t i = 0; i < len; i++)
-      this->write(data[i]);
+    this->buffer_->insert(this->buffer_->end(), data, data + len);
   }
   void encode_string(uint32_t field_id, const std::string &value, bool force = false) {
     this->encode_string(field_id, value.data(), value.size());

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -15,6 +15,16 @@ void BangBangClimate::setup() {
     this->publish_state();
   });
   this->current_temperature = this->sensor_->state;
+
+  // register for humidity values and get initial state
+  if (this->humidity_sensor_ != nullptr) {
+    this->humidity_sensor_->add_on_state_callback([this](float state) {
+      this->current_humidity = state;
+      this->publish_state();
+    });
+    this->current_humidity = this->humidity_sensor_->state;
+  }
+
   // restore set points
   auto restore = this->restore_state_();
   if (restore.has_value()) {
@@ -47,6 +57,8 @@ void BangBangClimate::control(const climate::ClimateCall &call) {
 climate::ClimateTraits BangBangClimate::traits() {
   auto traits = climate::ClimateTraits();
   traits.set_supports_current_temperature(true);
+  if (this->humidity_sensor_ != nullptr)
+    traits.set_supports_current_humidity(true);
   traits.set_supported_modes({
       climate::CLIMATE_MODE_OFF,
   });
@@ -171,6 +183,7 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
 BangBangClimate::BangBangClimate()
     : idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
 void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
+void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
 Trigger<> *BangBangClimate::get_idle_trigger() const { return this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger_; }
 void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }

esphome/components/bang_bang/bang_bang_climate.h

@@ -24,6 +24,7 @@ class BangBangClimate : public climate::Climate, public Component {
   void dump_config() override;
 
   void set_sensor(sensor::Sensor *sensor);
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor);
   Trigger<> *get_idle_trigger() const;
   Trigger<> *get_cool_trigger() const;
   void set_supports_cool(bool supports_cool);
@@ -48,6 +49,9 @@ class BangBangClimate : public climate::Climate, public Component {
 
   /// The sensor used for getting the current temperature
   sensor::Sensor *sensor_{nullptr};
+  /// The sensor used for getting the current humidity
+  sensor::Sensor *humidity_sensor_{nullptr};
+
   /** The trigger to call when the controller should switch to idle mode.
    *
    * In idle mode, the controller is assumed to have both heating and cooling disabled.

esphome/components/bang_bang/climate.py

@@ -8,6 +8,7 @@ from esphome.const import (
     CONF_DEFAULT_TARGET_TEMPERATURE_HIGH,
     CONF_DEFAULT_TARGET_TEMPERATURE_LOW,
     CONF_HEAT_ACTION,
+    CONF_HUMIDITY_SENSOR,
     CONF_ID,
     CONF_IDLE_ACTION,
     CONF_SENSOR,
@@ -22,6 +23,7 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(BangBangClimate),
             cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
+            cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
             cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
             cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
             cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
@@ -47,6 +49,10 @@ async def to_code(config):
     sens = await cg.get_variable(config[CONF_SENSOR])
     cg.add(var.set_sensor(sens))
 
+    if CONF_HUMIDITY_SENSOR in config:
+        sens = await cg.get_variable(config[CONF_HUMIDITY_SENSOR])
+        cg.add(var.set_humidity_sensor(sens))
+
     normal_config = BangBangClimateTargetTempConfig(
         config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW],
         config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH],

esphome/components/bl0940/sensor.py

@@ -18,6 +18,7 @@ from esphome.const import (
     UNIT_KILOWATT_HOURS,
     UNIT_VOLT,
     UNIT_WATT,
+    STATE_CLASS_TOTAL_INCREASING,
 )
 
 DEPENDENCIES = ["uart"]
@@ -54,6 +55,7 @@ CONFIG_SCHEMA = (
                 unit_of_measurement=UNIT_KILOWATT_HOURS,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_ENERGY,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
             ),
             cv.Optional(CONF_INTERNAL_TEMPERATURE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_CELSIUS,

esphome/components/bl0942/sensor.py

@@ -19,6 +19,7 @@ from esphome.const import (
     UNIT_VOLT,
     UNIT_WATT,
     UNIT_HERTZ,
+    STATE_CLASS_TOTAL_INCREASING,
 )
 
 DEPENDENCIES = ["uart"]
@@ -52,6 +53,7 @@ CONFIG_SCHEMA = (
                 unit_of_measurement=UNIT_KILOWATT_HOURS,
                 accuracy_decimals=0,
                 device_class=DEVICE_CLASS_ENERGY,
+                state_class=STATE_CLASS_TOTAL_INCREASING,
             ),
             cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(
                 unit_of_measurement=UNIT_HERTZ,

esphome/components/bp1658cj/bp1658cj.cpp

@@ -90,40 +90,41 @@ void BP1658CJ::set_channel_value_(uint8_t channel, uint16_t value) {
 
 void BP1658CJ::write_bit_(bool value) {
   this->data_pin_->digital_write(value);
-  this->clock_pin_->digital_write(true);
-
   delayMicroseconds(BP1658CJ_DELAY);
-
+  this->clock_pin_->digital_write(true);
+  delayMicroseconds(BP1658CJ_DELAY);
   this->clock_pin_->digital_write(false);
+  delayMicroseconds(BP1658CJ_DELAY);
 }
 
 void BP1658CJ::write_byte_(uint8_t data) {
   for (uint8_t mask = 0x80; mask; mask >>= 1) {
     this->write_bit_(data & mask);
-    delayMicroseconds(BP1658CJ_DELAY);
   }
 
   // ack bit
   this->data_pin_->pin_mode(gpio::FLAG_INPUT);
   this->clock_pin_->digital_write(true);
-
   delayMicroseconds(BP1658CJ_DELAY);
-
   this->clock_pin_->digital_write(false);
+  delayMicroseconds(BP1658CJ_DELAY);
   this->data_pin_->pin_mode(gpio::FLAG_OUTPUT);
 }
 
 void BP1658CJ::write_buffer_(uint8_t *buffer, uint8_t size) {
   this->data_pin_->digital_write(false);
+  delayMicroseconds(BP1658CJ_DELAY);
   this->clock_pin_->digital_write(false);
+  delayMicroseconds(BP1658CJ_DELAY);
 
   for (uint32_t i = 0; i < size; i++) {
     this->write_byte_(buffer[i]);
-    delayMicroseconds(BP1658CJ_DELAY);
   }
 
   this->clock_pin_->digital_write(true);
+  delayMicroseconds(BP1658CJ_DELAY);
   this->data_pin_->digital_write(true);
+  delayMicroseconds(BP1658CJ_DELAY);
 }
 
 }  // namespace bp1658cj

esphome/components/climate/__init__.py

@@ -8,6 +8,7 @@ from esphome.const import (
     CONF_AWAY,
     CONF_AWAY_COMMAND_TOPIC,
     CONF_AWAY_STATE_TOPIC,
+    CONF_CURRENT_HUMIDITY_STATE_TOPIC,
     CONF_CURRENT_TEMPERATURE_STATE_TOPIC,
     CONF_CUSTOM_FAN_MODE,
     CONF_CUSTOM_PRESET,
@@ -28,6 +29,8 @@ from esphome.const import (
     CONF_SWING_MODE,
     CONF_SWING_MODE_COMMAND_TOPIC,
     CONF_SWING_MODE_STATE_TOPIC,
+    CONF_TARGET_HUMIDITY_COMMAND_TOPIC,
+    CONF_TARGET_HUMIDITY_STATE_TOPIC,
     CONF_TARGET_TEMPERATURE,
     CONF_TARGET_TEMPERATURE_COMMAND_TOPIC,
     CONF_TARGET_TEMPERATURE_STATE_TOPIC,
@@ -106,6 +109,9 @@ CLIMATE_SWING_MODES = {
 validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True)
 
 CONF_CURRENT_TEMPERATURE = "current_temperature"
+CONF_MIN_HUMIDITY = "min_humidity"
+CONF_MAX_HUMIDITY = "max_humidity"
+CONF_TARGET_HUMIDITY = "target_humidity"
 
 visual_temperature = cv.float_with_unit(
     "visual_temperature", "(°C|° C|°|C|° K|° K|K|°F|° F|F)?"
@@ -153,6 +159,8 @@ CLIMATE_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).
                 cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature,
                 cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature,
                 cv.Optional(CONF_TEMPERATURE_STEP): VISUAL_TEMPERATURE_STEP_SCHEMA,
+                cv.Optional(CONF_MIN_HUMIDITY): cv.percentage_int,
+                cv.Optional(CONF_MAX_HUMIDITY): cv.percentage_int,
             }
         ),
         cv.Optional(CONF_ACTION_STATE_TOPIC): cv.All(
@@ -167,6 +175,9 @@ CLIMATE_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).
         cv.Optional(CONF_CURRENT_TEMPERATURE_STATE_TOPIC): cv.All(
             cv.requires_component("mqtt"), cv.publish_topic
         ),
+        cv.Optional(CONF_CURRENT_HUMIDITY_STATE_TOPIC): cv.All(
+            cv.requires_component("mqtt"), cv.publish_topic
+        ),
         cv.Optional(CONF_FAN_MODE_COMMAND_TOPIC): cv.All(
             cv.requires_component("mqtt"), cv.publish_topic
         ),
@@ -209,6 +220,12 @@ CLIMATE_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).
         cv.Optional(CONF_TARGET_TEMPERATURE_LOW_STATE_TOPIC): cv.All(
             cv.requires_component("mqtt"), cv.publish_topic
         ),
+        cv.Optional(CONF_TARGET_HUMIDITY_COMMAND_TOPIC): cv.All(
+            cv.requires_component("mqtt"), cv.publish_topic
+        ),
+        cv.Optional(CONF_TARGET_HUMIDITY_STATE_TOPIC): cv.All(
+            cv.requires_component("mqtt"), cv.publish_topic
+        ),
         cv.Optional(CONF_ON_CONTROL): automation.validate_automation(
             {
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ControlTrigger),
@@ -238,6 +255,10 @@ async def setup_climate_core_(var, config):
                 visual[CONF_TEMPERATURE_STEP][CONF_CURRENT_TEMPERATURE],
             )
         )
+    if CONF_MIN_HUMIDITY in visual:
+        cg.add(var.set_visual_min_humidity_override(visual[CONF_MIN_HUMIDITY]))
+    if CONF_MAX_HUMIDITY in visual:
+        cg.add(var.set_visual_max_humidity_override(visual[CONF_MAX_HUMIDITY]))
 
     if CONF_MQTT_ID in config:
         mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
@@ -255,6 +276,12 @@ async def setup_climate_core_(var, config):
                     config[CONF_CURRENT_TEMPERATURE_STATE_TOPIC]
                 )
             )
+        if CONF_CURRENT_HUMIDITY_STATE_TOPIC in config:
+            cg.add(
+                mqtt_.set_custom_current_humidity_state_topic(
+                    config[CONF_CURRENT_HUMIDITY_STATE_TOPIC]
+                )
+            )
         if CONF_FAN_MODE_COMMAND_TOPIC in config:
             cg.add(
                 mqtt_.set_custom_fan_mode_command_topic(
@@ -323,6 +350,18 @@ async def setup_climate_core_(var, config):
                     config[CONF_TARGET_TEMPERATURE_LOW_STATE_TOPIC]
                 )
             )
+        if CONF_TARGET_HUMIDITY_COMMAND_TOPIC in config:
+            cg.add(
+                mqtt_.set_custom_target_humidity_command_topic(
+                    config[CONF_TARGET_HUMIDITY_COMMAND_TOPIC]
+                )
+            )
+        if CONF_TARGET_HUMIDITY_STATE_TOPIC in config:
+            cg.add(
+                mqtt_.set_custom_target_humidity_state_topic(
+                    config[CONF_TARGET_HUMIDITY_STATE_TOPIC]
+                )
+            )
 
     for conf in config.get(CONF_ON_STATE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
@@ -351,6 +390,7 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
         cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
         cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
         cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.templatable(cv.temperature),
+        cv.Optional(CONF_TARGET_HUMIDITY): cv.templatable(cv.percentage_int),
         cv.Optional(CONF_AWAY): cv.invalid("Use preset instead"),
         cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
             validate_climate_fan_mode
@@ -387,6 +427,9 @@ async def climate_control_to_code(config, action_id, template_arg, args):
             config[CONF_TARGET_TEMPERATURE_HIGH], args, float
         )
         cg.add(var.set_target_temperature_high(template_))
+    if CONF_TARGET_HUMIDITY in config:
+        template_ = await cg.templatable(config[CONF_TARGET_HUMIDITY], args, float)
+        cg.add(var.set_target_humidity(template_))
     if CONF_FAN_MODE in config:
         template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))

esphome/components/climate/automation.h

@@ -14,6 +14,7 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
   TEMPLATABLE_VALUE(float, target_temperature)
   TEMPLATABLE_VALUE(float, target_temperature_low)
   TEMPLATABLE_VALUE(float, target_temperature_high)
+  TEMPLATABLE_VALUE(float, target_humidity)
   TEMPLATABLE_VALUE(bool, away)
   TEMPLATABLE_VALUE(ClimateFanMode, fan_mode)
   TEMPLATABLE_VALUE(std::string, custom_fan_mode)
@@ -27,6 +28,7 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
     call.set_target_temperature(this->target_temperature_.optional_value(x...));
     call.set_target_temperature_low(this->target_temperature_low_.optional_value(x...));
     call.set_target_temperature_high(this->target_temperature_high_.optional_value(x...));
+    call.set_target_humidity(this->target_humidity_.optional_value(x...));
     if (away_.has_value()) {
       call.set_preset(away_.value(x...) ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME);
     }

esphome/components/climate/climate.cpp

@@ -45,6 +45,9 @@ void ClimateCall::perform() {
   if (this->target_temperature_high_.has_value()) {
     ESP_LOGD(TAG, "  Target Temperature High: %.2f", *this->target_temperature_high_);
   }
+  if (this->target_humidity_.has_value()) {
+    ESP_LOGD(TAG, "  Target Humidity: %.0f", *this->target_humidity_);
+  }
   this->parent_->control(*this);
 }
 void ClimateCall::validate_() {
@@ -262,10 +265,16 @@ ClimateCall &ClimateCall::set_target_temperature_high(float target_temperature_h
   this->target_temperature_high_ = target_temperature_high;
   return *this;
 }
+ClimateCall &ClimateCall::set_target_humidity(float target_humidity) {
+  this->target_humidity_ = target_humidity;
+  return *this;
+}
+
 const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_; }
 const optional<float> &ClimateCall::get_target_temperature() const { return this->target_temperature_; }
 const optional<float> &ClimateCall::get_target_temperature_low() const { return this->target_temperature_low_; }
 const optional<float> &ClimateCall::get_target_temperature_high() const { return this->target_temperature_high_; }
+const optional<float> &ClimateCall::get_target_humidity() const { return this->target_humidity_; }
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
 const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
 const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
@@ -283,6 +292,10 @@ ClimateCall &ClimateCall::set_target_temperature(optional<float> target_temperat
   this->target_temperature_ = target_temperature;
   return *this;
 }
+ClimateCall &ClimateCall::set_target_humidity(optional<float> target_humidity) {
+  this->target_humidity_ = target_humidity;
+  return *this;
+}
 ClimateCall &ClimateCall::set_mode(optional<ClimateMode> mode) {
   this->mode_ = mode;
   return *this;
@@ -343,6 +356,9 @@ void Climate::save_state_() {
   } else {
     state.target_temperature = this->target_temperature;
   }
+  if (traits.get_supports_target_humidity()) {
+    state.target_humidity = this->target_humidity;
+  }
   if (traits.get_supports_fan_modes() && fan_mode.has_value()) {
     state.uses_custom_fan_mode = false;
     state.fan_mode = this->fan_mode.value();
@@ -408,6 +424,12 @@ void Climate::publish_state() {
   } else {
     ESP_LOGD(TAG, "  Target Temperature: %.2f°C", this->target_temperature);
   }
+  if (traits.get_supports_current_humidity()) {
+    ESP_LOGD(TAG, "  Current Humidity: %.0f%%", this->current_humidity);
+  }
+  if (traits.get_supports_target_humidity()) {
+    ESP_LOGD(TAG, "  Target Humidity: %.0f%%", this->target_humidity);
+  }
 
   // Send state to frontend
   this->state_callback_.call(*this);
@@ -427,6 +449,12 @@ ClimateTraits Climate::get_traits() {
     traits.set_visual_target_temperature_step(*this->visual_target_temperature_step_override_);
     traits.set_visual_current_temperature_step(*this->visual_current_temperature_step_override_);
   }
+  if (this->visual_min_humidity_override_.has_value()) {
+    traits.set_visual_min_humidity(*this->visual_min_humidity_override_);
+  }
+  if (this->visual_max_humidity_override_.has_value()) {
+    traits.set_visual_max_humidity(*this->visual_max_humidity_override_);
+  }
 
   return traits;
 }
@@ -441,6 +469,12 @@ void Climate::set_visual_temperature_step_override(float target, float current)
   this->visual_target_temperature_step_override_ = target;
   this->visual_current_temperature_step_override_ = current;
 }
+void Climate::set_visual_min_humidity_override(float visual_min_humidity_override) {
+  this->visual_min_humidity_override_ = visual_min_humidity_override;
+}
+void Climate::set_visual_max_humidity_override(float visual_max_humidity_override) {
+  this->visual_max_humidity_override_ = visual_max_humidity_override;
+}
 
 ClimateCall Climate::make_call() { return ClimateCall(this); }
 
@@ -454,6 +488,9 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   } else {
     call.set_target_temperature(this->target_temperature);
   }
+  if (traits.get_supports_target_humidity()) {
+    call.set_target_humidity(this->target_humidity);
+  }
   if (traits.get_supports_fan_modes() || !traits.get_supported_custom_fan_modes().empty()) {
     call.set_fan_mode(this->fan_mode);
   }
@@ -474,6 +511,9 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   } else {
     climate->target_temperature = this->target_temperature;
   }
+  if (traits.get_supports_target_humidity()) {
+    climate->target_humidity = this->target_humidity;
+  }
   if (traits.get_supports_fan_modes() && !this->uses_custom_fan_mode) {
     climate->fan_mode = this->fan_mode;
   }
@@ -530,17 +570,25 @@ void Climate::dump_traits_(const char *tag) {
   auto traits = this->get_traits();
   ESP_LOGCONFIG(tag, "ClimateTraits:");
   ESP_LOGCONFIG(tag, "  [x] Visual settings:");
-  ESP_LOGCONFIG(tag, "      - Min: %.1f", traits.get_visual_min_temperature());
-  ESP_LOGCONFIG(tag, "      - Max: %.1f", traits.get_visual_max_temperature());
-  ESP_LOGCONFIG(tag, "      - Step:");
+  ESP_LOGCONFIG(tag, "      - Min temperature: %.1f", traits.get_visual_min_temperature());
+  ESP_LOGCONFIG(tag, "      - Max temperature: %.1f", traits.get_visual_max_temperature());
+  ESP_LOGCONFIG(tag, "      - Temperature step:");
   ESP_LOGCONFIG(tag, "          Target: %.1f", traits.get_visual_target_temperature_step());
   ESP_LOGCONFIG(tag, "          Current: %.1f", traits.get_visual_current_temperature_step());
+  ESP_LOGCONFIG(tag, "      - Min humidity: %.0f", traits.get_visual_min_humidity());
+  ESP_LOGCONFIG(tag, "      - Max humidity: %.0f", traits.get_visual_max_humidity());
   if (traits.get_supports_current_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports current temperature");
   }
+  if (traits.get_supports_current_humidity()) {
+    ESP_LOGCONFIG(tag, "  [x] Supports current humidity");
+  }
   if (traits.get_supports_two_point_target_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");
   }
+  if (traits.get_supports_target_humidity()) {
+    ESP_LOGCONFIG(tag, "  [x] Supports target humidity");
+  }
   if (traits.get_supports_action()) {
     ESP_LOGCONFIG(tag, "  [x] Supports action");
   }

esphome/components/climate/climate.h

@@ -64,6 +64,10 @@ class ClimateCall {
    * For climate devices with two point target temperature control
    */
   ClimateCall &set_target_temperature_high(optional<float> target_temperature_high);
+  /// Set the target humidity of the climate device.
+  ClimateCall &set_target_humidity(float target_humidity);
+  /// Set the target humidity of the climate device.
+  ClimateCall &set_target_humidity(optional<float> target_humidity);
   /// Set the fan mode of the climate device.
   ClimateCall &set_fan_mode(ClimateFanMode fan_mode);
   /// Set the fan mode of the climate device.
@@ -93,6 +97,7 @@ class ClimateCall {
   const optional<float> &get_target_temperature() const;
   const optional<float> &get_target_temperature_low() const;
   const optional<float> &get_target_temperature_high() const;
+  const optional<float> &get_target_humidity() const;
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
   const optional<std::string> &get_custom_fan_mode() const;
@@ -107,6 +112,7 @@ class ClimateCall {
   optional<float> target_temperature_;
   optional<float> target_temperature_low_;
   optional<float> target_temperature_high_;
+  optional<float> target_humidity_;
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
   optional<std::string> custom_fan_mode_;
@@ -136,6 +142,7 @@ struct ClimateDeviceRestoreState {
       float target_temperature_high;
     };
   };
+  float target_humidity;
 
   /// Convert this struct to a climate call that can be performed.
   ClimateCall to_call(Climate *climate);
@@ -160,24 +167,34 @@ struct ClimateDeviceRestoreState {
  */
 class Climate : public EntityBase {
  public:
+  Climate() {}
+
   /// The active mode of the climate device.
   ClimateMode mode{CLIMATE_MODE_OFF};
+
   /// The active state of the climate device.
   ClimateAction action{CLIMATE_ACTION_OFF};
+
   /// The current temperature of the climate device, as reported from the integration.
   float current_temperature{NAN};
 
+  /// The current humidity of the climate device, as reported from the integration.
+  float current_humidity{NAN};
+
   union {
     /// The target temperature of the climate device.
     float target_temperature;
     struct {
       /// The minimum target temperature of the climate device, for climate devices with split target temperature.
-      float target_temperature_low;
+      float target_temperature_low{NAN};
       /// The maximum target temperature of the climate device, for climate devices with split target temperature.
-      float target_temperature_high;
+      float target_temperature_high{NAN};
     };
   };
 
+  /// The target humidity of the climate device.
+  float target_humidity;
+
   /// The active fan mode of the climate device.
   optional<ClimateFanMode> fan_mode;
 
@@ -231,6 +248,8 @@ class Climate : public EntityBase {
   void set_visual_min_temperature_override(float visual_min_temperature_override);
   void set_visual_max_temperature_override(float visual_max_temperature_override);
   void set_visual_temperature_step_override(float target, float current);
+  void set_visual_min_humidity_override(float visual_min_humidity_override);
+  void set_visual_max_humidity_override(float visual_max_humidity_override);
 
  protected:
   friend ClimateCall;
@@ -280,6 +299,8 @@ class Climate : public EntityBase {
   optional<float> visual_max_temperature_override_{};
   optional<float> visual_target_temperature_step_override_{};
   optional<float> visual_current_temperature_step_override_{};
+  optional<float> visual_min_humidity_override_{};
+  optional<float> visual_max_humidity_override_{};
 };
 
 }  // namespace climate

esphome/components/climate/climate_traits.h

@@ -44,10 +44,18 @@ class ClimateTraits {
   void set_supports_current_temperature(bool supports_current_temperature) {
     supports_current_temperature_ = supports_current_temperature;
   }
+  bool get_supports_current_humidity() const { return supports_current_humidity_; }
+  void set_supports_current_humidity(bool supports_current_humidity) {
+    supports_current_humidity_ = supports_current_humidity;
+  }
   bool get_supports_two_point_target_temperature() const { return supports_two_point_target_temperature_; }
   void set_supports_two_point_target_temperature(bool supports_two_point_target_temperature) {
     supports_two_point_target_temperature_ = supports_two_point_target_temperature;
   }
+  bool get_supports_target_humidity() const { return supports_target_humidity_; }
+  void set_supports_target_humidity(bool supports_target_humidity) {
+    supports_target_humidity_ = supports_target_humidity;
+  }
   void set_supported_modes(std::set<ClimateMode> modes) { supported_modes_ = std::move(modes); }
   void add_supported_mode(ClimateMode mode) { supported_modes_.insert(mode); }
   ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
@@ -153,6 +161,11 @@ class ClimateTraits {
   int8_t get_target_temperature_accuracy_decimals() const;
   int8_t get_current_temperature_accuracy_decimals() const;
 
+  float get_visual_min_humidity() const { return visual_min_humidity_; }
+  void set_visual_min_humidity(float visual_min_humidity) { visual_min_humidity_ = visual_min_humidity; }
+  float get_visual_max_humidity() const { return visual_max_humidity_; }
+  void set_visual_max_humidity(float visual_max_humidity) { visual_max_humidity_ = visual_max_humidity; }
+
  protected:
   void set_mode_support_(climate::ClimateMode mode, bool supported) {
     if (supported) {
@@ -177,7 +190,9 @@ class ClimateTraits {
   }
 
   bool supports_current_temperature_{false};
+  bool supports_current_humidity_{false};
   bool supports_two_point_target_temperature_{false};
+  bool supports_target_humidity_{false};
   std::set<climate::ClimateMode> supported_modes_ = {climate::CLIMATE_MODE_OFF};
   bool supports_action_{false};
   std::set<climate::ClimateFanMode> supported_fan_modes_;
@@ -190,6 +205,8 @@ class ClimateTraits {
   float visual_max_temperature_{30};
   float visual_target_temperature_step_{0.1};
   float visual_current_temperature_step_{0.1};
+  float visual_min_humidity_{30};
+  float visual_max_humidity_{99};
 };
 
 }  // namespace climate

esphome/components/copy/fan/copy_fan.cpp

@@ -12,6 +12,7 @@ void CopyFan::setup() {
     this->oscillating = source_->oscillating;
     this->speed = source_->speed;
     this->direction = source_->direction;
+    this->preset_mode = source_->preset_mode;
     this->publish_state();
   });
 
@@ -19,6 +20,7 @@ void CopyFan::setup() {
   this->oscillating = source_->oscillating;
   this->speed = source_->speed;
   this->direction = source_->direction;
+  this->preset_mode = source_->preset_mode;
   this->publish_state();
 }
 
@@ -33,6 +35,7 @@ fan::FanTraits CopyFan::get_traits() {
   traits.set_speed(base.supports_speed());
   traits.set_supported_speed_count(base.supported_speed_count());
   traits.set_direction(base.supports_direction());
+  traits.set_supported_preset_modes(base.supported_preset_modes());
   return traits;
 }
 
@@ -46,6 +49,8 @@ void CopyFan::control(const fan::FanCall &call) {
     call2.set_speed(*call.get_speed());
   if (call.get_direction().has_value())
     call2.set_direction(*call.get_direction());
+  if (!call.get_preset_mode().empty())
+    call2.set_preset_mode(call.get_preset_mode());
   call2.perform();
 }
 

esphome/components/display/__init__.py

@@ -18,8 +18,8 @@ from esphome.core import coroutine_with_priority
 IS_PLATFORM_COMPONENT = True
 
 display_ns = cg.esphome_ns.namespace("display")
-Display = display_ns.class_("Display")
-DisplayBuffer = display_ns.class_("DisplayBuffer")
+Display = display_ns.class_("Display", cg.PollingComponent)
+DisplayBuffer = display_ns.class_("DisplayBuffer", Display)
 DisplayPage = display_ns.class_("DisplayPage")
 DisplayPagePtr = DisplayPage.operator("ptr")
 DisplayRef = Display.operator("ref")
@@ -58,7 +58,7 @@ BASIC_DISPLAY_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_LAMBDA): cv.lambda_,
     }
-)
+).extend(cv.polling_component_schema("1s"))
 
 FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
     {
@@ -116,6 +116,7 @@ async def setup_display_core_(var, config):
 
 
 async def register_display(var, config):
+    await cg.register_component(var, config)
     await setup_display_core_(var, config)
 
 
@@ -144,7 +145,7 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
     DisplayPageShowNextAction,
     maybe_simple_id(
         {
-            cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayBuffer)),
+            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -158,7 +159,7 @@ async def display_page_show_next_to_code(config, action_id, template_arg, args):
     DisplayPageShowPrevAction,
     maybe_simple_id(
         {
-            cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayBuffer)),
+            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -172,7 +173,7 @@ async def display_page_show_previous_to_code(config, action_id, template_arg, ar
     DisplayIsDisplayingPageCondition,
     cv.maybe_simple_value(
         {
-            cv.GenerateID(CONF_ID): cv.use_id(DisplayBuffer),
+            cv.GenerateID(CONF_ID): cv.use_id(Display),
             cv.Required(CONF_PAGE_ID): cv.use_id(DisplayPage),
         },
         key=CONF_PAGE_ID,

esphome/components/display/display.cpp

@@ -166,6 +166,13 @@ void Display::qr_code(int x, int y, qr_code::QrCode *qr_code, Color color_on, in
 }
 #endif  // USE_QR_CODE
 
+#ifdef USE_GRAPHICAL_DISPLAY_MENU
+void Display::menu(int x, int y, graphical_display_menu::GraphicalDisplayMenu *menu, int width, int height) {
+  Rect rect(x, y, width, height);
+  menu->draw(this, &rect);
+}
+#endif  // USE_GRAPHICAL_DISPLAY_MENU
+
 void Display::get_text_bounds(int x, int y, const char *text, BaseFont *font, TextAlign align, int *x1, int *y1,
                               int *width, int *height) {
   int x_offset, baseline;

esphome/components/display/display.h

@@ -17,6 +17,10 @@
 #include "esphome/components/qr_code/qr_code.h"
 #endif
 
+#ifdef USE_GRAPHICAL_DISPLAY_MENU
+#include "esphome/components/graphical_display_menu/graphical_display_menu.h"
+#endif
+
 namespace esphome {
 namespace display {
 
@@ -163,7 +167,7 @@ class BaseFont {
   virtual void measure(const char *str, int *width, int *x_offset, int *baseline, int *height) = 0;
 };
 
-class Display {
+class Display : public PollingComponent {
  public:
   /// Fill the entire screen with the given color.
   virtual void fill(Color color);
@@ -392,6 +396,17 @@ class Display {
   void qr_code(int x, int y, qr_code::QrCode *qr_code, Color color_on = COLOR_ON, int scale = 1);
 #endif
 
+#ifdef USE_GRAPHICAL_DISPLAY_MENU
+  /**
+   * @param x The x coordinate of the upper left corner
+   * @param y The y coordinate of the upper left corner
+   * @param menu The GraphicalDisplayMenu to draw
+   * @param width Width of the menu
+   * @param height Height of the menu
+   */
+  void menu(int x, int y, graphical_display_menu::GraphicalDisplayMenu *menu, int width, int height);
+#endif  // USE_GRAPHICAL_DISPLAY_MENU
+
   /** Get the text bounds of the given string.
    *
    * @param x The x coordinate to place the string at, can be 0 if only interested in dimensions.

esphome/components/display_menu_base/display_menu_base.cpp

@@ -172,6 +172,8 @@ void DisplayMenuComponent::show_main() {
 
   this->process_initial_();
 
+  this->on_before_show();
+
   if (this->active_ && this->editing_)
     this->finish_editing_();
 
@@ -188,6 +190,8 @@ void DisplayMenuComponent::show_main() {
   }
 
   this->draw_and_update();
+
+  this->on_after_show();
 }
 
 void DisplayMenuComponent::show() {
@@ -196,18 +200,26 @@ void DisplayMenuComponent::show() {
 
   this->process_initial_();
 
+  this->on_before_show();
+
   if (!this->active_) {
     this->active_ = true;
     this->draw_and_update();
   }
+
+  this->on_after_show();
 }
 
 void DisplayMenuComponent::hide() {
   if (this->check_healthy_and_active_()) {
+    this->on_before_hide();
+
     if (this->editing_)
       this->finish_editing_();
     this->active_ = false;
     this->update();
+
+    this->on_after_hide();
   }
 }
 

esphome/components/display_menu_base/display_menu_base.h

@@ -60,6 +60,11 @@ class DisplayMenuComponent : public Component {
     update();
   }
 
+  virtual void on_before_show(){};
+  virtual void on_after_show(){};
+  virtual void on_before_hide(){};
+  virtual void on_after_hide(){};
+
   uint8_t rows_;
   bool active_;
   MenuMode mode_;

esphome/components/display_menu_base/menu_item.cpp

@@ -5,6 +5,29 @@
 namespace esphome {
 namespace display_menu_base {
 
+const LogString *menu_item_type_to_string(MenuItemType type) {
+  switch (type) {
+    case MenuItemType::MENU_ITEM_LABEL:
+      return LOG_STR("MENU_ITEM_LABEL");
+    case MenuItemType::MENU_ITEM_MENU:
+      return LOG_STR("MENU_ITEM_MENU");
+    case MenuItemType::MENU_ITEM_BACK:
+      return LOG_STR("MENU_ITEM_BACK");
+    case MenuItemType::MENU_ITEM_SELECT:
+      return LOG_STR("MENU_ITEM_SELECT");
+    case MenuItemType::MENU_ITEM_NUMBER:
+      return LOG_STR("MENU_ITEM_NUMBER");
+    case MenuItemType::MENU_ITEM_SWITCH:
+      return LOG_STR("MENU_ITEM_SWITCH");
+    case MenuItemType::MENU_ITEM_COMMAND:
+      return LOG_STR("MENU_ITEM_COMMAND");
+    case MenuItemType::MENU_ITEM_CUSTOM:
+      return LOG_STR("MENU_ITEM_CUSTOM");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
+
 void MenuItem::on_enter() { this->on_enter_callbacks_.call(); }
 
 void MenuItem::on_leave() { this->on_leave_callbacks_.call(); }

esphome/components/display_menu_base/menu_item.h

@@ -14,6 +14,7 @@
 #endif
 
 #include <vector>
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace display_menu_base {
@@ -29,6 +30,9 @@ enum MenuItemType {
   MENU_ITEM_CUSTOM,
 };
 
+/// @brief Returns a string representation of a menu item type suitable for logging
+const LogString *menu_item_type_to_string(MenuItemType type);
+
 class MenuItem;
 class MenuItemMenu;
 using value_getter_t = std::function<std::string(const MenuItem *)>;

esphome/components/ektf2232/touchscreen/__init__.py

@@ -12,7 +12,6 @@ ektf2232_ns = cg.esphome_ns.namespace("ektf2232")
 EKTF2232Touchscreen = ektf2232_ns.class_(
     "EKTF2232Touchscreen",
     touchscreen.Touchscreen,
-    cg.Component,
     i2c.I2CDevice,
 )
 
@@ -28,17 +27,14 @@ CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
             ),
             cv.Required(CONF_RTS_PIN): pins.gpio_output_pin_schema,
         }
-    )
-    .extend(i2c.i2c_device_schema(0x15))
-    .extend(cv.COMPONENT_SCHEMA)
+    ).extend(i2c.i2c_device_schema(0x15))
 )
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
     await touchscreen.register_touchscreen(var, config)
+    await i2c.register_i2c_device(var, config)
 
     interrupt_pin = await cg.gpio_pin_expression(config[CONF_INTERRUPT_PIN])
     cg.add(var.set_interrupt_pin(interrupt_pin))

esphome/components/ektf2232/touchscreen/ektf2232.cpp

@@ -15,16 +15,12 @@ static const uint8_t GET_X_RES[4] = {0x53, 0x60, 0x00, 0x00};
 static const uint8_t GET_Y_RES[4] = {0x53, 0x63, 0x00, 0x00};
 static const uint8_t GET_POWER_STATE_CMD[4] = {0x53, 0x50, 0x00, 0x01};
 
-void EKTF2232TouchscreenStore::gpio_intr(EKTF2232TouchscreenStore *store) { store->touch = true; }
-
 void EKTF2232Touchscreen::setup() {
   ESP_LOGCONFIG(TAG, "Setting up EKT2232 Touchscreen...");
   this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
   this->interrupt_pin_->setup();
 
-  this->store_.pin = this->interrupt_pin_->to_isr();
-  this->interrupt_pin_->attach_interrupt(EKTF2232TouchscreenStore::gpio_intr, &this->store_,
-                                         gpio::INTERRUPT_FALLING_EDGE);
+  this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
 
   this->rts_pin_->setup();
 
@@ -45,7 +41,7 @@ void EKTF2232Touchscreen::setup() {
     this->mark_failed();
     return;
   }
-  this->x_resolution_ = ((received[2])) | ((received[3] & 0xf0) << 4);
+  this->x_raw_max_ = ((received[2])) | ((received[3] & 0xf0) << 4);
 
   this->write(GET_Y_RES, 4);
   if (this->read(received, 4)) {
@@ -54,19 +50,14 @@ void EKTF2232Touchscreen::setup() {
     this->mark_failed();
     return;
   }
-  this->y_resolution_ = ((received[2])) | ((received[3] & 0xf0) << 4);
-  this->store_.touch = false;
+  this->y_raw_max_ = ((received[2])) | ((received[3] & 0xf0) << 4);
 
   this->set_power_state(true);
 }
 
-void EKTF2232Touchscreen::loop() {
-  if (!this->store_.touch)
-    return;
-  this->store_.touch = false;
-
+void EKTF2232Touchscreen::update_touches() {
   uint8_t touch_count = 0;
-  std::vector<TouchPoint> touches;
+  int16_t x_raw, y_raw;
 
   uint8_t raw[8];
   this->read(raw, 8);
@@ -75,45 +66,15 @@ void EKTF2232Touchscreen::loop() {
       touch_count++;
   }
 
-  if (touch_count == 0) {
-    for (auto *listener : this->touch_listeners_)
-      listener->release();
-    return;
-  }
-
   touch_count = std::min<uint8_t>(touch_count, 2);
 
   ESP_LOGV(TAG, "Touch count: %d", touch_count);
 
   for (int i = 0; i < touch_count; i++) {
     uint8_t *d = raw + 1 + (i * 3);
-    uint32_t raw_x = (d[0] & 0xF0) << 4 | d[1];
-    uint32_t raw_y = (d[0] & 0x0F) << 8 | d[2];
-
-    raw_x = raw_x * this->display_height_ - 1;
-    raw_y = raw_y * this->display_width_ - 1;
-
-    TouchPoint tp;
-    switch (this->rotation_) {
-      case ROTATE_0_DEGREES:
-        tp.y = raw_x / this->x_resolution_;
-        tp.x = this->display_width_ - 1 - (raw_y / this->y_resolution_);
-        break;
-      case ROTATE_90_DEGREES:
-        tp.x = raw_x / this->x_resolution_;
-        tp.y = raw_y / this->y_resolution_;
-        break;
-      case ROTATE_180_DEGREES:
-        tp.y = this->display_height_ - 1 - (raw_x / this->x_resolution_);
-        tp.x = raw_y / this->y_resolution_;
-        break;
-      case ROTATE_270_DEGREES:
-        tp.x = this->display_height_ - 1 - (raw_x / this->x_resolution_);
-        tp.y = this->display_width_ - 1 - (raw_y / this->y_resolution_);
-        break;
-    }
-
-    this->defer([this, tp]() { this->send_touch_(tp); });
+    x_raw = (d[0] & 0xF0) << 4 | d[1];
+    y_raw = (d[0] & 0x0F) << 8 | d[2];
+    this->add_raw_touch_position_(i, x_raw, y_raw);
   }
 }
 
@@ -126,7 +87,7 @@ void EKTF2232Touchscreen::set_power_state(bool enable) {
 bool EKTF2232Touchscreen::get_power_state() {
   uint8_t received[4];
   this->write(GET_POWER_STATE_CMD, 4);
-  this->store_.touch = false;
+  this->store_.touched = false;
   this->read(received, 4);
   return (received[1] >> 3) & 1;
 }
@@ -145,14 +106,14 @@ bool EKTF2232Touchscreen::soft_reset_() {
 
   uint8_t received[4];
   uint16_t timeout = 1000;
-  while (!this->store_.touch && timeout > 0) {
+  while (!this->store_.touched && timeout > 0) {
     delay(1);
     timeout--;
   }
   if (timeout > 0)
-    this->store_.touch = true;
+    this->store_.touched = true;
   this->read(received, 4);
-  this->store_.touch = false;
+  this->store_.touched = false;
 
   return !memcmp(received, HELLO, 4);
 }

esphome/components/ektf2232/touchscreen/ektf2232.h

@@ -9,19 +9,11 @@
 namespace esphome {
 namespace ektf2232 {
 
-struct EKTF2232TouchscreenStore {
-  volatile bool touch;
-  ISRInternalGPIOPin pin;
-
-  static void gpio_intr(EKTF2232TouchscreenStore *store);
-};
-
 using namespace touchscreen;
 
-class EKTF2232Touchscreen : public Touchscreen, public Component, public i2c::I2CDevice {
+class EKTF2232Touchscreen : public Touchscreen, public i2c::I2CDevice {
  public:
   void setup() override;
-  void loop() override;
   void dump_config() override;
 
   void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
@@ -33,12 +25,10 @@ class EKTF2232Touchscreen : public Touchscreen, public Component, public i2c::I2
  protected:
   void hard_reset_();
   bool soft_reset_();
+  void update_touches() override;
 
   InternalGPIOPin *interrupt_pin_;
   GPIOPin *rts_pin_;
-  EKTF2232TouchscreenStore store_;
-  uint16_t x_resolution_;
-  uint16_t y_resolution_;
 };
 
 }  // namespace ektf2232

esphome/components/ens160/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@vincentscode"]

esphome/components/ens160/ens160.cpp

@@ -0,0 +1,321 @@
+// ENS160 sensor with I2C interface from ScioSense
+//
+// Datasheet: https://www.sciosense.com/wp-content/uploads/documents/SC-001224-DS-7-ENS160-Datasheet.pdf
+//
+// Implementation based on:
+//   https://github.com/sciosense/ENS160_driver
+
+#include "ens160.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace ens160 {
+
+static const char *const TAG = "ens160";
+
+static const uint8_t ENS160_BOOTING = 10;
+
+static const uint16_t ENS160_PART_ID = 0x0160;
+
+static const uint8_t ENS160_REG_PART_ID = 0x00;
+static const uint8_t ENS160_REG_OPMODE = 0x10;
+static const uint8_t ENS160_REG_CONFIG = 0x11;
+static const uint8_t ENS160_REG_COMMAND = 0x12;
+static const uint8_t ENS160_REG_TEMP_IN = 0x13;
+static const uint8_t ENS160_REG_DATA_STATUS = 0x20;
+static const uint8_t ENS160_REG_DATA_AQI = 0x21;
+static const uint8_t ENS160_REG_DATA_TVOC = 0x22;
+static const uint8_t ENS160_REG_DATA_ECO2 = 0x24;
+
+static const uint8_t ENS160_REG_GPR_READ_0 = 0x48;
+static const uint8_t ENS160_REG_GPR_READ_4 = ENS160_REG_GPR_READ_0 + 4;
+
+static const uint8_t ENS160_COMMAND_NOP = 0x00;
+static const uint8_t ENS160_COMMAND_CLRGPR = 0xCC;
+static const uint8_t ENS160_COMMAND_GET_APPVER = 0x0E;
+
+static const uint8_t ENS160_OPMODE_RESET = 0xF0;
+static const uint8_t ENS160_OPMODE_IDLE = 0x01;
+static const uint8_t ENS160_OPMODE_STD = 0x02;
+
+static const uint8_t ENS160_DATA_STATUS_STATAS = 0x80;
+static const uint8_t ENS160_DATA_STATUS_STATER = 0x40;
+static const uint8_t ENS160_DATA_STATUS_VALIDITY = 0x0C;
+static const uint8_t ENS160_DATA_STATUS_NEWDAT = 0x02;
+static const uint8_t ENS160_DATA_STATUS_NEWGPR = 0x01;
+
+// helps remove reserved bits in aqi data register
+static const uint8_t ENS160_DATA_AQI = 0x07;
+
+void ENS160Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ENS160...");
+
+  // check part_id
+  uint16_t part_id;
+  if (!this->read_bytes(ENS160_REG_PART_ID, reinterpret_cast<uint8_t *>(&part_id), 2)) {
+    this->error_code_ = COMMUNICATION_FAILED;
+    this->mark_failed();
+    return;
+  }
+  if (part_id != ENS160_PART_ID) {
+    this->error_code_ = INVALID_ID;
+    this->mark_failed();
+    return;
+  }
+
+  // set mode to reset
+  if (!this->write_byte(ENS160_REG_OPMODE, ENS160_OPMODE_RESET)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+  delay(ENS160_BOOTING);
+
+  // check status
+  uint8_t status_value;
+  if (!this->read_byte(ENS160_REG_DATA_STATUS, &status_value)) {
+    this->error_code_ = READ_FAILED;
+    this->mark_failed();
+    return;
+  }
+  this->validity_flag_ = static_cast<ValidityFlag>((ENS160_DATA_STATUS_VALIDITY & status_value) >> 2);
+
+  if (this->validity_flag_ == INVALID_OUTPUT) {
+    this->error_code_ = VALIDITY_INVALID;
+    this->mark_failed();
+    return;
+  }
+
+  // set mode to idle
+  if (!this->write_byte(ENS160_REG_OPMODE, ENS160_OPMODE_IDLE)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+  // clear command
+  if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_NOP)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+  if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_CLRGPR)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+
+  // read firmware version
+  if (!this->write_byte(ENS160_REG_COMMAND, ENS160_COMMAND_GET_APPVER)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+  uint8_t version_data[3];
+  if (!this->read_bytes(ENS160_REG_GPR_READ_4, version_data, 3)) {
+    this->error_code_ = READ_FAILED;
+    this->mark_failed();
+    return;
+  }
+  this->firmware_ver_major_ = version_data[0];
+  this->firmware_ver_minor_ = version_data[1];
+  this->firmware_ver_build_ = version_data[2];
+
+  // set mode to standard
+  if (!this->write_byte(ENS160_REG_OPMODE, ENS160_OPMODE_STD)) {
+    this->error_code_ = WRITE_FAILED;
+    this->mark_failed();
+    return;
+  }
+
+  // read opmode and check standard mode is achieved before finishing Setup
+  uint8_t op_mode;
+  if (!this->read_byte(ENS160_REG_OPMODE, &op_mode)) {
+    this->error_code_ = READ_FAILED;
+    this->mark_failed();
+    return;
+  }
+
+  if (op_mode != ENS160_OPMODE_STD) {
+    this->error_code_ = STD_OPMODE_FAILED;
+    this->mark_failed();
+    return;
+  }
+}
+
+void ENS160Component::update() {
+  uint8_t status_value, data_ready;
+
+  if (!this->read_byte(ENS160_REG_DATA_STATUS, &status_value)) {
+    ESP_LOGW(TAG, "Error reading status register");
+    this->status_set_warning();
+    return;
+  }
+
+  // verbose status logging
+  ESP_LOGV(TAG, "Status: ENS160 STATAS bit    0x%x",
+           (ENS160_DATA_STATUS_STATAS & (status_value)) == ENS160_DATA_STATUS_STATAS);
+  ESP_LOGV(TAG, "Status: ENS160 STATER bit    0x%x",
+           (ENS160_DATA_STATUS_STATER & (status_value)) == ENS160_DATA_STATUS_STATER);
+  ESP_LOGV(TAG, "Status: ENS160 VALIDITY FLAG 0x%02x", (ENS160_DATA_STATUS_VALIDITY & status_value) >> 2);
+  ESP_LOGV(TAG, "Status: ENS160 NEWDAT bit    0x%x",
+           (ENS160_DATA_STATUS_NEWDAT & (status_value)) == ENS160_DATA_STATUS_NEWDAT);
+  ESP_LOGV(TAG, "Status: ENS160 NEWGPR bit    0x%x",
+           (ENS160_DATA_STATUS_NEWGPR & (status_value)) == ENS160_DATA_STATUS_NEWGPR);
+
+  data_ready = ENS160_DATA_STATUS_NEWDAT & status_value;
+  this->validity_flag_ = static_cast<ValidityFlag>((ENS160_DATA_STATUS_VALIDITY & status_value) >> 2);
+
+  switch (validity_flag_) {
+    case NORMAL_OPERATION:
+      if (data_ready != ENS160_DATA_STATUS_NEWDAT) {
+        ESP_LOGD(TAG, "ENS160 readings unavailable - Normal Operation but readings not ready");
+        return;
+      }
+      break;
+    case INITIAL_STARTUP:
+      if (!this->initial_startup_) {
+        this->initial_startup_ = true;
+        ESP_LOGI(TAG, "ENS160 readings unavailable - 1 hour startup required after first power on");
+      }
+      return;
+    case WARMING_UP:
+      if (!this->warming_up_) {
+        this->warming_up_ = true;
+        ESP_LOGI(TAG, "ENS160 readings not available yet - Warming up requires 3 minutes");
+        this->send_env_data_();
+      }
+      return;
+    case INVALID_OUTPUT:
+      ESP_LOGE(TAG, "ENS160 Invalid Status - No Invalid Output");
+      this->status_set_warning();
+      return;
+  }
+
+  // read new data
+  uint16_t data_eco2;
+  if (!this->read_bytes(ENS160_REG_DATA_ECO2, reinterpret_cast<uint8_t *>(&data_eco2), 2)) {
+    ESP_LOGW(TAG, "Error reading eCO2 data register");
+    this->status_set_warning();
+    return;
+  }
+  if (this->co2_ != nullptr) {
+    this->co2_->publish_state(data_eco2);
+  }
+
+  uint16_t data_tvoc;
+  if (!this->read_bytes(ENS160_REG_DATA_TVOC, reinterpret_cast<uint8_t *>(&data_tvoc), 2)) {
+    ESP_LOGW(TAG, "Error reading TVOC data register");
+    this->status_set_warning();
+    return;
+  }
+  if (this->tvoc_ != nullptr) {
+    this->tvoc_->publish_state(data_tvoc);
+  }
+
+  uint8_t data_aqi;
+  if (!this->read_byte(ENS160_REG_DATA_AQI, &data_aqi)) {
+    ESP_LOGW(TAG, "Error reading AQI data register");
+    this->status_set_warning();
+    return;
+  }
+  if (this->aqi_ != nullptr) {
+    // remove reserved bits, just in case they are used in future
+    data_aqi = ENS160_DATA_AQI & data_aqi;
+
+    this->aqi_->publish_state(data_aqi);
+  }
+
+  this->status_clear_warning();
+
+  // set temperature and humidity compensation data
+  this->send_env_data_();
+}
+
+void ENS160Component::send_env_data_() {
+  if (this->temperature_ == nullptr && this->humidity_ == nullptr)
+    return;
+
+  float temperature = NAN;
+  if (this->temperature_ != nullptr)
+    temperature = this->temperature_->state;
+
+  if (std::isnan(temperature) || temperature < -40.0f || temperature > 85.0f) {
+    ESP_LOGW(TAG, "Invalid external temperature - compensation values not updated");
+    return;
+  } else {
+    ESP_LOGV(TAG, "External temperature compensation: %.1f°C", temperature);
+  }
+
+  float humidity = NAN;
+  if (this->humidity_ != nullptr)
+    humidity = this->humidity_->state;
+
+  if (std::isnan(humidity) || humidity < 0.0f || humidity > 100.0f) {
+    ESP_LOGW(TAG, "Invalid external humidity - compensation values not updated");
+    return;
+  } else {
+    ESP_LOGV(TAG, "External humidity compensation:    %.1f%%", humidity);
+  }
+
+  uint16_t t = (uint16_t) ((temperature + 273.15f) * 64.0f);
+  uint16_t h = (uint16_t) (humidity * 512.0f);
+
+  uint8_t data[4];
+  data[0] = t & 0xff;
+  data[1] = (t >> 8) & 0xff;
+  data[2] = h & 0xff;
+  data[3] = (h >> 8) & 0xff;
+
+  if (!this->write_bytes(ENS160_REG_TEMP_IN, data, 4)) {
+    ESP_LOGE(TAG, "Error writing compensation values");
+    this->status_set_warning();
+    return;
+  }
+}
+
+void ENS160Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "ENS160:");
+
+  switch (this->error_code_) {
+    case COMMUNICATION_FAILED:
+      ESP_LOGE(TAG, "Communication failed! Is the sensor connected?");
+      break;
+    case READ_FAILED:
+      ESP_LOGE(TAG, "Error reading from register");
+      break;
+    case WRITE_FAILED:
+      ESP_LOGE(TAG, "Error writing to register");
+      break;
+    case INVALID_ID:
+      ESP_LOGE(TAG, "Sensor reported an invalid ID. Is this a ENS160?");
+      break;
+    case VALIDITY_INVALID:
+      ESP_LOGE(TAG, "Invalid Device Status - No valid output");
+      break;
+    case STD_OPMODE_FAILED:
+      ESP_LOGE(TAG, "Device failed to achieve Standard Operating Mode");
+      break;
+    case NONE:
+      ESP_LOGD(TAG, "Setup successful");
+      break;
+  }
+  ESP_LOGI(TAG, "Firmware Version: %d.%d.%d", this->firmware_ver_major_, this->firmware_ver_minor_,
+           this->firmware_ver_build_);
+
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "CO2 Sensor:", this->co2_);
+  LOG_SENSOR("  ", "TVOC Sensor:", this->tvoc_);
+  LOG_SENSOR("  ", "AQI Sensor:", this->aqi_);
+
+  if (this->temperature_ != nullptr && this->humidity_ != nullptr) {
+    LOG_SENSOR("  ", "  Temperature Compensation:", this->temperature_);
+    LOG_SENSOR("  ", "  Humidity Compensation:", this->humidity_);
+  } else {
+    ESP_LOGCONFIG(TAG, "  Compensation: Not configured");
+  }
+}
+
+}  // namespace ens160
+}  // namespace esphome

esphome/components/ens160/ens160.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace ens160 {
+
+class ENS160Component : public PollingComponent, public i2c::I2CDevice, public sensor::Sensor {
+ public:
+  void set_co2(sensor::Sensor *co2) { co2_ = co2; }
+  void set_tvoc(sensor::Sensor *tvoc) { tvoc_ = tvoc; }
+  void set_aqi(sensor::Sensor *aqi) { aqi_ = aqi; }
+
+  void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
+  void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+  void send_env_data_();
+
+  enum ErrorCode {
+    NONE = 0,
+    COMMUNICATION_FAILED,
+    INVALID_ID,
+    VALIDITY_INVALID,
+    READ_FAILED,
+    WRITE_FAILED,
+    STD_OPMODE_FAILED,
+  } error_code_{NONE};
+
+  enum ValidityFlag {
+    NORMAL_OPERATION = 0,
+    WARMING_UP,
+    INITIAL_STARTUP,
+    INVALID_OUTPUT,
+  } validity_flag_;
+
+  bool warming_up_{false};
+  bool initial_startup_{false};
+
+  uint8_t firmware_ver_major_{0};
+  uint8_t firmware_ver_minor_{0};
+  uint8_t firmware_ver_build_{0};
+
+  sensor::Sensor *co2_{nullptr};
+  sensor::Sensor *tvoc_{nullptr};
+  sensor::Sensor *aqi_{nullptr};
+
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *temperature_{nullptr};
+};
+
+}  // namespace ens160
+}  // namespace esphome

esphome/components/ens160/sensor.py

@@ -0,0 +1,87 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ECO2,
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    CONF_TVOC,
+    DEVICE_CLASS_AQI,
+    DEVICE_CLASS_CARBON_DIOXIDE,
+    DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS_PARTS,
+    ICON_CHEMICAL_WEAPON,
+    ICON_MOLECULE_CO2,
+    ICON_RADIATOR,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PARTS_PER_BILLION,
+    UNIT_PARTS_PER_MILLION,
+)
+
+CODEOWNERS = ["@vincentscode"]
+DEPENDENCIES = ["i2c"]
+
+ens160_ns = cg.esphome_ns.namespace("ens160")
+ENS160Component = ens160_ns.class_(
+    "ENS160Component", cg.PollingComponent, i2c.I2CDevice, sensor.Sensor
+)
+
+CONF_AQI = "aqi"
+CONF_COMPENSATION = "compensation"
+UNIT_INDEX = "index"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ENS160Component),
+            cv.Required(CONF_ECO2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_MILLION,
+                icon=ICON_MOLECULE_CO2,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_CARBON_DIOXIDE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Required(CONF_TVOC): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_BILLION,
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_VOLATILE_ORGANIC_COMPOUNDS_PARTS,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Required(CONF_AQI): sensor.sensor_schema(
+                icon=ICON_CHEMICAL_WEAPON,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_AQI,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_COMPENSATION): cv.Schema(
+                {
+                    cv.Required(CONF_TEMPERATURE): cv.use_id(sensor.Sensor),
+                    cv.Required(CONF_HUMIDITY): cv.use_id(sensor.Sensor),
+                }
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x53))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    sens = await sensor.new_sensor(config[CONF_ECO2])
+    cg.add(var.set_co2(sens))
+    sens = await sensor.new_sensor(config[CONF_TVOC])
+    cg.add(var.set_tvoc(sens))
+    sens = await sensor.new_sensor(config[CONF_AQI])
+    cg.add(var.set_aqi(sens))
+
+    if CONF_COMPENSATION in config:
+        compensation_config = config[CONF_COMPENSATION]
+        sens = await cg.get_variable(compensation_config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+        sens = await cg.get_variable(compensation_config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))

esphome/components/esp32/__init__.py

@@ -3,23 +3,26 @@ from typing import Union, Optional
 from pathlib import Path
 import logging
 import os
+import esphome.final_validate as fv
 
 from esphome.helpers import copy_file_if_changed, write_file_if_changed, mkdir_p
 from esphome.const import (
+    CONF_ADVANCED,
     CONF_BOARD,
     CONF_COMPONENTS,
+    CONF_ESPHOME,
     CONF_FRAMEWORK,
+    CONF_IGNORE_EFUSE_MAC_CRC,
     CONF_NAME,
+    CONF_PATH,
+    CONF_PLATFORMIO_OPTIONS,
+    CONF_REF,
+    CONF_REFRESH,
     CONF_SOURCE,
     CONF_TYPE,
+    CONF_URL,
     CONF_VARIANT,
     CONF_VERSION,
-    CONF_ADVANCED,
-    CONF_REFRESH,
-    CONF_PATH,
-    CONF_URL,
-    CONF_REF,
-    CONF_IGNORE_EFUSE_MAC_CRC,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
     KEY_NAME,
@@ -327,6 +330,32 @@ def _detect_variant(value):
     return value
 
 
+def final_validate(config):
+    if CONF_PLATFORMIO_OPTIONS not in fv.full_config.get()[CONF_ESPHOME]:
+        return config
+
+    pio_flash_size_key = "board_upload.flash_size"
+    pio_partitions_key = "board_build.partitions"
+    if (
+        CONF_PARTITIONS in config
+        and pio_partitions_key
+        in fv.full_config.get()[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS]
+    ):
+        raise cv.Invalid(
+            f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
+        )
+
+    if (
+        pio_flash_size_key
+        in fv.full_config.get()[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS]
+    ):
+        raise cv.Invalid(
+            f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
+        )
+
+    return config
+
+
 CONF_PLATFORM_VERSION = "platform_version"
 
 ARDUINO_FRAMEWORK_SCHEMA = cv.All(
@@ -387,6 +416,7 @@ FRAMEWORK_SCHEMA = cv.typed_schema(
 
 
 FLASH_SIZES = [
+    "2MB",
     "4MB",
     "8MB",
     "16MB",
@@ -394,6 +424,7 @@ FLASH_SIZES = [
 ]
 
 CONF_FLASH_SIZE = "flash_size"
+CONF_PARTITIONS = "partitions"
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -401,6 +432,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_FLASH_SIZE, default="4MB"): cv.one_of(
                 *FLASH_SIZES, upper=True
             ),
+            cv.Optional(CONF_PARTITIONS): cv.file_,
             cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
             cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
         }
@@ -410,6 +442,9 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+FINAL_VALIDATE_SCHEMA = cv.Schema(final_validate)
+
+
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
@@ -427,7 +462,7 @@ async def to_code(config):
 
     add_extra_script(
         "post",
-        "post_build2.py",
+        "post_build.py",
         os.path.join(os.path.dirname(__file__), "post_build.py.script"),
     )
 
@@ -463,6 +498,10 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
 
         cg.add_platformio_option("board_build.partitions", "partitions.csv")
+        if CONF_PARTITIONS in config:
+            add_extra_build_file(
+                "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
+            )
 
         for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
             add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
@@ -507,7 +546,10 @@ async def to_code(config):
             [f"platformio/framework-arduinoespressif32@{conf[CONF_SOURCE]}"],
         )
 
-        cg.add_platformio_option("board_build.partitions", "partitions.csv")
+        if CONF_PARTITIONS in config:
+            cg.add_platformio_option("board_build.partitions", config[CONF_PARTITIONS])
+        else:
+            cg.add_platformio_option("board_build.partitions", "partitions.csv")
 
         cg.add_define(
             "USE_ARDUINO_VERSION_CODE",
@@ -518,6 +560,7 @@ async def to_code(config):
 
 
 APP_PARTITION_SIZES = {
+    "2MB": 0x0C0000,  # 768 KB
     "4MB": 0x1C0000,  # 1792 KB
     "8MB": 0x3C0000,  # 3840 KB
     "16MB": 0x7C0000,  # 7936 KB
@@ -597,20 +640,22 @@ def _write_sdkconfig():
 # Called by writer.py
 def copy_files():
     if CORE.using_arduino:
-        write_file_if_changed(
-            CORE.relative_build_path("partitions.csv"),
-            get_arduino_partition_csv(
-                CORE.platformio_options.get("board_upload.flash_size")
-            ),
-        )
+        if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
+            write_file_if_changed(
+                CORE.relative_build_path("partitions.csv"),
+                get_arduino_partition_csv(
+                    CORE.platformio_options.get("board_upload.flash_size")
+                ),
+            )
     if CORE.using_esp_idf:
         _write_sdkconfig()
-        write_file_if_changed(
-            CORE.relative_build_path("partitions.csv"),
-            get_idf_partition_csv(
-                CORE.platformio_options.get("board_upload.flash_size")
-            ),
-        )
+        if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
+            write_file_if_changed(
+                CORE.relative_build_path("partitions.csv"),
+                get_idf_partition_csv(
+                    CORE.platformio_options.get("board_upload.flash_size")
+                ),
+            )
         # IDF build scripts look for version string to put in the build.
         # However, if the build path does not have an initialized git repo,
         # and no version.txt file exists, the CMake script fails for some setups.

esphome/components/esp32/boards.py

@@ -133,6 +133,10 @@ ESP32_BOARD_PINS = {
         "BUTTON": 0,
         "SWITCH": 0,
     },
+    "airm2m_core_esp32c3": {
+        "LED1_BUILTIN": 12,
+        "LED2_BUILTIN": 13,
+    },
     "alksesp32": {
         "A0": 32,
         "A1": 33,

esphome/components/esp32/gpio.py

@@ -3,15 +3,13 @@ from typing import Any
 
 from esphome.const import (
     CONF_ID,
-    CONF_INPUT,
     CONF_INVERTED,
     CONF_MODE,
     CONF_NUMBER,
     CONF_OPEN_DRAIN,
     CONF_OUTPUT,
-    CONF_PULLDOWN,
-    CONF_PULLUP,
     CONF_IGNORE_STRAPPING_WARNING,
+    PLATFORM_ESP32,
 )
 from esphome import pins
 from esphome.core import CORE
@@ -33,7 +31,6 @@ from .const import (
     esp32_ns,
 )
 
-
 from .gpio_esp32 import esp32_validate_gpio_pin, esp32_validate_supports
 from .gpio_esp32_s2 import esp32_s2_validate_gpio_pin, esp32_s2_validate_supports
 from .gpio_esp32_c3 import esp32_c3_validate_gpio_pin, esp32_c3_validate_supports
@@ -42,7 +39,6 @@ from .gpio_esp32_c2 import esp32_c2_validate_gpio_pin, esp32_c2_validate_support
 from .gpio_esp32_c6 import esp32_c6_validate_gpio_pin, esp32_c6_validate_supports
 from .gpio_esp32_h2 import esp32_h2_validate_gpio_pin, esp32_h2_validate_supports
 
-
 ESP32InternalGPIOPin = esp32_ns.class_("ESP32InternalGPIOPin", cg.InternalGPIOPin)
 
 
@@ -161,33 +157,22 @@ DRIVE_STRENGTHS = {
 }
 gpio_num_t = cg.global_ns.enum("gpio_num_t")
 
-
 CONF_DRIVE_STRENGTH = "drive_strength"
 ESP32_PIN_SCHEMA = cv.All(
-    {
-        cv.GenerateID(): cv.declare_id(ESP32InternalGPIOPin),
-        cv.Required(CONF_NUMBER): validate_gpio_pin,
-        cv.Optional(CONF_MODE, default={}): cv.Schema(
-            {
-                cv.Optional(CONF_INPUT, default=False): cv.boolean,
-                cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
-                cv.Optional(CONF_OPEN_DRAIN, default=False): cv.boolean,
-                cv.Optional(CONF_PULLUP, default=False): cv.boolean,
-                cv.Optional(CONF_PULLDOWN, default=False): cv.boolean,
-            }
-        ),
-        cv.Optional(CONF_INVERTED, default=False): cv.boolean,
-        cv.Optional(CONF_IGNORE_STRAPPING_WARNING, default=False): cv.boolean,
-        cv.Optional(CONF_DRIVE_STRENGTH, default="20mA"): cv.All(
-            cv.float_with_unit("current", "mA", optional_unit=True),
-            cv.enum(DRIVE_STRENGTHS),
-        ),
-    },
+    pins.gpio_base_schema(ESP32InternalGPIOPin, validate_gpio_pin).extend(
+        {
+            cv.Optional(CONF_IGNORE_STRAPPING_WARNING, default=False): cv.boolean,
+            cv.Optional(CONF_DRIVE_STRENGTH, default="20mA"): cv.All(
+                cv.float_with_unit("current", "mA", optional_unit=True),
+                cv.enum(DRIVE_STRENGTHS),
+            ),
+        }
+    ),
     validate_supports,
 )
 
 
-@pins.PIN_SCHEMA_REGISTRY.register("esp32", ESP32_PIN_SCHEMA)
+@pins.PIN_SCHEMA_REGISTRY.register(PLATFORM_ESP32, ESP32_PIN_SCHEMA)
 async def esp32_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]

esphome/components/esp32_camera/__init__.py

@@ -25,6 +25,11 @@ AUTO_LOAD = ["psram"]
 
 esp32_camera_ns = cg.esphome_ns.namespace("esp32_camera")
 ESP32Camera = esp32_camera_ns.class_("ESP32Camera", cg.PollingComponent, cg.EntityBase)
+ESP32CameraImageData = esp32_camera_ns.struct("CameraImageData")
+# Triggers
+ESP32CameraImageTrigger = esp32_camera_ns.class_(
+    "ESP32CameraImageTrigger", automation.Trigger.template()
+)
 ESP32CameraStreamStartTrigger = esp32_camera_ns.class_(
     "ESP32CameraStreamStartTrigger",
     automation.Trigger.template(),
@@ -139,6 +144,7 @@ CONF_IDLE_FRAMERATE = "idle_framerate"
 # stream trigger
 CONF_ON_STREAM_START = "on_stream_start"
 CONF_ON_STREAM_STOP = "on_stream_stop"
+CONF_ON_IMAGE = "on_image"
 
 camera_range_param = cv.int_range(min=-2, max=2)
 
@@ -221,6 +227,11 @@ CONFIG_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
                 ),
             }
         ),
+        cv.Optional(CONF_ON_IMAGE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ESP32CameraImageTrigger),
+            }
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -289,3 +300,9 @@ async def to_code(config):
     for conf in config.get(CONF_ON_STREAM_STOP, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
+
+    for conf in config.get(CONF_ON_IMAGE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(ESP32CameraImageData, "image")], conf
+        )

esphome/components/esp32_camera/esp32_camera.cpp

@@ -37,7 +37,7 @@ void ESP32Camera::setup() {
                           "framebuffer_task",  // name
                           1024,                // stack size
                           nullptr,             // task pv params
-                          0,                   // priority
+                          1,                   // priority
                           nullptr,             // handle
                           1                    // core
   );
@@ -335,8 +335,8 @@ void ESP32Camera::set_idle_update_interval(uint32_t idle_update_interval) {
 }
 
 /* ---------------- public API (specific) ---------------- */
-void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&f) {
-  this->new_image_callback_.add(std::move(f));
+void ESP32Camera::add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback) {
+  this->new_image_callback_.add(std::move(callback));
 }
 void ESP32Camera::add_stream_start_callback(std::function<void()> &&callback) {
   this->stream_start_callback_.add(std::move(callback));

esphome/components/esp32_camera/esp32_camera.h

@@ -86,6 +86,11 @@ class CameraImage {
   uint8_t requesters_;
 };
 
+struct CameraImageData {
+  uint8_t *data;
+  size_t length;
+};
+
 /* ---------------- CameraImageReader class ---------------- */
 class CameraImageReader {
  public:
@@ -147,12 +152,12 @@ class ESP32Camera : public Component, public EntityBase {
   void dump_config() override;
   float get_setup_priority() const override;
   /* public API (specific) */
-  void add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&f);
   void start_stream(CameraRequester requester);
   void stop_stream(CameraRequester requester);
   void request_image(CameraRequester requester);
   void update_camera_parameters();
 
+  void add_image_callback(std::function<void(std::shared_ptr<CameraImage>)> &&callback);
   void add_stream_start_callback(std::function<void()> &&callback);
   void add_stream_stop_callback(std::function<void()> &&callback);
 
@@ -196,7 +201,7 @@ class ESP32Camera : public Component, public EntityBase {
   uint8_t stream_requesters_{0};
   QueueHandle_t framebuffer_get_queue_;
   QueueHandle_t framebuffer_return_queue_;
-  CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_;
+  CallbackManager<void(std::shared_ptr<CameraImage>)> new_image_callback_{};
   CallbackManager<void()> stream_start_callback_{};
   CallbackManager<void()> stream_stop_callback_{};
 
@@ -207,6 +212,18 @@ class ESP32Camera : public Component, public EntityBase {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern ESP32Camera *global_esp32_camera;
 
+class ESP32CameraImageTrigger : public Trigger<CameraImageData> {
+ public:
+  explicit ESP32CameraImageTrigger(ESP32Camera *parent) {
+    parent->add_image_callback([this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
+      CameraImageData camera_image_data{};
+      camera_image_data.length = image->get_data_length();
+      camera_image_data.data = image->get_data_buffer();
+      this->trigger(camera_image_data);
+    });
+  }
+};
+
 class ESP32CameraStreamStartTrigger : public Trigger<> {
  public:
   explicit ESP32CameraStreamStartTrigger(ESP32Camera *parent) {

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -13,6 +13,8 @@ namespace esp32_rmt_led_strip {
 
 static const char *const TAG = "esp32_rmt_led_strip";
 
+static const uint32_t RMT_CLK_FREQ = 80000000;
+
 static const uint8_t RMT_CLK_DIV = 2;
 
 void ESP32RMTLEDStripLightOutput::setup() {
@@ -65,7 +67,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
 
 void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bit0_low, uint32_t bit1_high,
                                                  uint32_t bit1_low) {
-  float ratio = (float) APB_CLK_FREQ / RMT_CLK_DIV / 1e09f;
+  float ratio = (float) RMT_CLK_FREQ / RMT_CLK_DIV / 1e09f;
 
   // 0-bit
   this->bit0_.duration0 = (uint32_t) (ratio * bit0_high);

esphome/components/esp8266/gpio.py

@@ -12,6 +12,7 @@ from esphome.const import (
     CONF_OUTPUT,
     CONF_PULLDOWN,
     CONF_PULLUP,
+    PLATFORM_ESP8266,
 )
 from esphome import pins
 from esphome.core import CORE, coroutine_with_priority
@@ -21,10 +22,8 @@ import esphome.codegen as cg
 from . import boards
 from .const import KEY_BOARD, KEY_ESP8266, KEY_PIN_INITIAL_STATES, esp8266_ns
 
-
 _LOGGER = logging.getLogger(__name__)
 
-
 ESP8266GPIOPin = esp8266_ns.class_("ESP8266GPIOPin", cg.InternalGPIOPin)
 
 
@@ -124,6 +123,8 @@ def validate_supports(value):
         (True, False, False, False, False),
         # OUTPUT
         (False, True, False, False, False),
+        # INPUT and OUTPUT, e.g. for i2c
+        (True, True, False, False, False),
         # INPUT_PULLUP
         (True, False, False, True, False),
         # INPUT_PULLDOWN_16
@@ -142,21 +143,11 @@ def validate_supports(value):
 
 
 ESP8266_PIN_SCHEMA = cv.All(
-    {
-        cv.GenerateID(): cv.declare_id(ESP8266GPIOPin),
-        cv.Required(CONF_NUMBER): validate_gpio_pin,
-        cv.Optional(CONF_MODE, default={}): cv.Schema(
-            {
-                cv.Optional(CONF_ANALOG, default=False): cv.boolean,
-                cv.Optional(CONF_INPUT, default=False): cv.boolean,
-                cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
-                cv.Optional(CONF_OPEN_DRAIN, default=False): cv.boolean,
-                cv.Optional(CONF_PULLUP, default=False): cv.boolean,
-                cv.Optional(CONF_PULLDOWN, default=False): cv.boolean,
-            }
-        ),
-        cv.Optional(CONF_INVERTED, default=False): cv.boolean,
-    },
+    pins.gpio_base_schema(
+        ESP8266GPIOPin,
+        validate_gpio_pin,
+        modes=pins.GPIO_STANDARD_MODES + (CONF_ANALOG,),
+    ),
     validate_supports,
 )
 
@@ -167,7 +158,7 @@ class PinInitialState:
     level: int = 255
 
 
-@pins.PIN_SCHEMA_REGISTRY.register("esp8266", ESP8266_PIN_SCHEMA)
+@pins.PIN_SCHEMA_REGISTRY.register(PLATFORM_ESP8266, ESP8266_PIN_SCHEMA)
 async def esp8266_pin_to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     num = config[CONF_NUMBER]

esphome/components/esp_adf/__init__.py

@@ -1,102 +0,0 @@
-import os
-
-import esphome.config_validation as cv
-import esphome.codegen as cg
-import esphome.final_validate as fv
-
-from esphome.components import esp32
-
-from esphome.const import CONF_ID, CONF_BOARD
-
-CODEOWNERS = ["@jesserockz"]
-DEPENDENCIES = ["esp32"]
-
-CONF_ESP_ADF_ID = "esp_adf_id"
-CONF_ESP_ADF = "esp_adf"
-
-esp_adf_ns = cg.esphome_ns.namespace("esp_adf")
-ESPADF = esp_adf_ns.class_("ESPADF", cg.Component)
-ESPADFPipeline = esp_adf_ns.class_("ESPADFPipeline", cg.Parented.template(ESPADF))
-
-SUPPORTED_BOARDS = {
-    "esp32s3box": "CONFIG_ESP32_S3_BOX_BOARD",
-    "esp32s3boxlite": "CONFIG_ESP32_S3_BOX_LITE_BOARD",
-    "esp32s3box3": "CONFIG_ESP32_S3_BOX_3_BOARD",
-}
-
-
-def _default_board(config):
-    config = config.copy()
-    if board := config.get(CONF_BOARD) is None:
-        board = esp32.get_board()
-        if board in SUPPORTED_BOARDS:
-            config[CONF_BOARD] = board
-    return config
-
-
-def final_validate_usable_board(platform: str):
-    def _validate(adf_config):
-        board = adf_config.get(CONF_BOARD)
-        if board not in SUPPORTED_BOARDS:
-            raise cv.Invalid(f"Board {board} is not supported by esp-adf {platform}")
-        return adf_config
-
-    return cv.Schema(
-        {cv.Required(CONF_ESP_ADF_ID): fv.id_declaration_match_schema(_validate)},
-        extra=cv.ALLOW_EXTRA,
-    )
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ESPADF),
-            cv.Optional(CONF_BOARD): cv.string_strict,
-        }
-    ),
-    _default_board,
-    cv.only_with_esp_idf,
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-
-    cg.add_define("USE_ESP_ADF")
-
-    cg.add_platformio_option("build_unflags", "-Wl,--end-group")
-
-    esp32.add_idf_component(
-        name="esp-adf",
-        repo="https://github.com/espressif/esp-adf",
-        path="components",
-        ref="v2.5",
-        components=["*"],
-        submodules=["components/esp-sr", "components/esp-adf-libs"],
-    )
-
-    esp32.add_idf_component(
-        name="esp-dsp",
-        repo="https://github.com/espressif/esp-dsp",
-        ref="v1.2.0",
-    )
-
-    cg.add_platformio_option(
-        "board_build.embed_txtfiles", "components/dueros_service/duer_profile"
-    )
-
-    if board := config.get(CONF_BOARD):
-        cg.add_define("USE_ESP_ADF_BOARD")
-
-        esp32.add_idf_sdkconfig_option(SUPPORTED_BOARDS[board], True)
-
-        esp32.add_extra_script(
-            "pre",
-            "apply_adf_patches.py",
-            os.path.join(os.path.dirname(__file__), "apply_adf_patches.py.script"),
-        )
-        esp32.add_extra_build_file(
-            "esp_adf_patches/idf_v4.4_freertos.patch",
-            "https://github.com/espressif/esp-adf/raw/v2.5/idf_patches/idf_v4.4_freertos.patch",
-        )

esphome/components/esp_adf/apply_adf_patches.py.script

@@ -1,23 +0,0 @@
-from os.path import join, isfile
-
-Import("env")
-
-FRAMEWORK_DIR = env.PioPlatform().get_package_dir("framework-espidf")
-patchflag_path = join(FRAMEWORK_DIR, ".adf-patching-done")
-
-PROJECT_DIR = env.get('PROJECT_DIR')
-
-PATCH_FILE = join(PROJECT_DIR, "esp_adf_patches", "idf_v4.4_freertos.patch")
-
-# patch file only if we didn't do it before
-if not isfile(patchflag_path):
-    print(PATCH_FILE)
-    assert isfile(PATCH_FILE)
-
-    env.Execute("patch -p1 -d %s -i %s" % (FRAMEWORK_DIR, PATCH_FILE))
-
-    def _touch(path):
-        with open(path, "w") as fp:
-            fp.write("")
-
-    env.Execute(lambda *args, **kwargs: _touch(patchflag_path))

esphome/components/esp_adf/esp_adf.cpp

@@ -1,30 +0,0 @@
-#include "esp_adf.h"
-#include "esphome/core/defines.h"
-
-#ifdef USE_ESP_IDF
-
-#ifdef USE_ESP_ADF_BOARD
-#include <board.h>
-#endif
-
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace esp_adf {
-
-static const char *const TAG = "esp_adf";
-
-void ESPADF::setup() {
-#ifdef USE_ESP_ADF_BOARD
-  ESP_LOGI(TAG, "Start codec chip");
-  audio_board_handle_t board_handle = audio_board_init();
-  audio_hal_ctrl_codec(board_handle->audio_hal, AUDIO_HAL_CODEC_MODE_BOTH, AUDIO_HAL_CTRL_START);
-#endif
-}
-
-float ESPADF::get_setup_priority() const { return setup_priority::HARDWARE; }
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/esp_adf/esp_adf.h

@@ -1,58 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP_IDF
-
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome {
-namespace esp_adf {
-
-static const size_t BUFFER_SIZE = 1024;
-
-enum class TaskEventType : uint8_t {
-  STARTING = 0,
-  STARTED,
-  RUNNING,
-  STOPPING,
-  STOPPED,
-  WARNING = 255,
-};
-
-struct TaskEvent {
-  TaskEventType type;
-  esp_err_t err;
-};
-
-struct CommandEvent {
-  bool stop;
-};
-
-struct DataEvent {
-  bool stop;
-  size_t len;
-  uint8_t data[BUFFER_SIZE];
-};
-
-class ESPADF;
-
-class ESPADFPipeline : public Parented<ESPADF> {};
-
-class ESPADF : public Component {
- public:
-  void setup() override;
-
-  float get_setup_priority() const override;
-
-  void lock() { this->lock_.lock(); }
-  bool try_lock() { return this->lock_.try_lock(); }
-  void unlock() { this->lock_.unlock(); }
-
- protected:
-  Mutex lock_;
-};
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/esp_adf/microphone/__init__.py

@@ -1,41 +0,0 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.components import microphone
-from esphome.const import CONF_ID
-
-from .. import (
-    CONF_ESP_ADF_ID,
-    ESPADF,
-    ESPADFPipeline,
-    esp_adf_ns,
-    final_validate_usable_board,
-)
-
-AUTO_LOAD = ["esp_adf"]
-CONFLICTS_WITH = ["i2s_audio"]
-DEPENDENCIES = ["esp32"]
-
-ESPADFMicrophone = esp_adf_ns.class_(
-    "ESPADFMicrophone", ESPADFPipeline, microphone.Microphone, cg.Component
-)
-
-
-CONFIG_SCHEMA = cv.All(
-    microphone.MICROPHONE_SCHEMA.extend(
-        {
-            cv.GenerateID(): cv.declare_id(ESPADFMicrophone),
-            cv.GenerateID(CONF_ESP_ADF_ID): cv.use_id(ESPADF),
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_with_esp_idf,
-)
-
-FINAL_VALIDATE_SCHEMA = final_validate_usable_board("microphone")
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await cg.register_parented(var, config[CONF_ESP_ADF_ID])
-
-    await microphone.register_microphone(var, config)

esphome/components/esp_adf/microphone/esp_adf_microphone.cpp

@@ -1,336 +0,0 @@
-#include "esp_adf_microphone.h"
-
-#ifdef USE_ESP_IDF
-
-#include <driver/i2s.h>
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <algorithm_stream.h>
-#include <audio_element.h>
-#include <audio_hal.h>
-#include <audio_pipeline.h>
-#include <filter_resample.h>
-#include <i2s_stream.h>
-#include <raw_stream.h>
-#include <recorder_sr.h>
-
-#include <board.h>
-
-namespace esphome {
-namespace esp_adf {
-
-static const char *const TAG = "esp_adf.microphone";
-
-void ESPADFMicrophone::setup() {
-  this->ring_buffer_ = rb_create(8000, sizeof(int16_t));
-  if (this->ring_buffer_ == nullptr) {
-    ESP_LOGW(TAG, "Could not allocate ring buffer.");
-    this->mark_failed();
-    return;
-  }
-
-  this->read_event_queue_ = xQueueCreate(20, sizeof(TaskEvent));
-  this->read_command_queue_ = xQueueCreate(20, sizeof(CommandEvent));
-}
-
-void ESPADFMicrophone::start() {
-  if (this->is_failed())
-    return;
-  if (this->state_ == microphone::STATE_STOPPING) {
-    ESP_LOGW(TAG, "Microphone is stopping, cannot start.");
-    return;
-  }
-  this->state_ = microphone::STATE_STARTING;
-}
-void ESPADFMicrophone::start_() {
-  if (!this->parent_->try_lock()) {
-    return;
-  }
-
-  xTaskCreate(ESPADFMicrophone::read_task, "read_task", 8192, (void *) this, 0, &this->read_task_handle_);
-}
-
-void ESPADFMicrophone::read_task(void *params) {
-  ESPADFMicrophone *this_mic = (ESPADFMicrophone *) params;
-  TaskEvent event;
-
-  ExternalRAMAllocator<int16_t> allocator(ExternalRAMAllocator<int16_t>::ALLOW_FAILURE);
-  int16_t *buffer = allocator.allocate(BUFFER_SIZE / sizeof(int16_t));
-  if (buffer == nullptr) {
-    event.type = TaskEventType::WARNING;
-    event.err = ESP_ERR_NO_MEM;
-    xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-    event.type = TaskEventType::STOPPED;
-    event.err = ESP_OK;
-    xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-    while (true) {
-      delay(10);
-    }
-    return;
-  }
-
-  event.type = TaskEventType::STARTING;
-  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-  audio_pipeline_cfg_t pipeline_cfg = {
-      .rb_size = 8 * 1024,
-  };
-  audio_pipeline_handle_t pipeline = audio_pipeline_init(&pipeline_cfg);
-
-  i2s_driver_config_t i2s_config = {
-      .mode = (i2s_mode_t) (I2S_MODE_MASTER | I2S_MODE_RX),
-      .sample_rate = 16000,
-      .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
-      .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
-      .communication_format = I2S_COMM_FORMAT_STAND_I2S,
-      .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM,
-      .dma_buf_count = 8,
-      .dma_buf_len = 128,
-      .use_apll = false,
-      .tx_desc_auto_clear = true,
-      .fixed_mclk = 0,
-      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
-      .bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
-  };
-
-  i2s_stream_cfg_t i2s_cfg = {
-      .type = AUDIO_STREAM_READER,
-      .i2s_config = i2s_config,
-      .i2s_port = static_cast<i2s_port_t>(CODEC_ADC_I2S_PORT),
-      .use_alc = false,
-      .volume = 0,
-      .out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
-      .task_stack = I2S_STREAM_TASK_STACK,
-      .task_core = I2S_STREAM_TASK_CORE,
-      .task_prio = I2S_STREAM_TASK_PRIO,
-      .stack_in_ext = false,
-      .multi_out_num = 0,
-      .uninstall_drv = true,
-      .need_expand = false,
-      .expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
-  };
-  audio_element_handle_t i2s_stream_reader = i2s_stream_init(&i2s_cfg);
-
-  rsp_filter_cfg_t rsp_cfg = {
-      .src_rate = 16000,
-      .src_ch = 2,
-      .dest_rate = 16000,
-      .dest_bits = 16,
-      .dest_ch = 1,
-      .src_bits = I2S_BITS_PER_SAMPLE_16BIT,
-      .mode = RESAMPLE_DECODE_MODE,
-      .max_indata_bytes = RSP_FILTER_BUFFER_BYTE,
-      .out_len_bytes = RSP_FILTER_BUFFER_BYTE,
-      .type = ESP_RESAMPLE_TYPE_AUTO,
-      .complexity = 2,
-      .down_ch_idx = 0,
-      .prefer_flag = ESP_RSP_PREFER_TYPE_SPEED,
-      .out_rb_size = RSP_FILTER_RINGBUFFER_SIZE,
-      .task_stack = RSP_FILTER_TASK_STACK,
-      .task_core = RSP_FILTER_TASK_CORE,
-      .task_prio = RSP_FILTER_TASK_PRIO,
-      .stack_in_ext = true,
-  };
-  audio_element_handle_t filter = rsp_filter_init(&rsp_cfg);
-
-  algorithm_stream_cfg_t algo_cfg = {
-      .input_type = ALGORITHM_STREAM_INPUT_TYPE1,
-      .task_stack = 10 * 1024,
-      .task_prio = ALGORITHM_STREAM_TASK_PERIOD,
-      .task_core = ALGORITHM_STREAM_PINNED_TO_CORE,
-      .out_rb_size = ALGORITHM_STREAM_RINGBUFFER_SIZE,
-      .stack_in_ext = true,
-      .rec_linear_factor = 1,
-      .ref_linear_factor = 1,
-      .debug_input = false,
-      .swap_ch = false,
-      // .algo_mask = ALGORITHM_STREAM_USE_AGC,
-      // .algo_mask = (ALGORITHM_STREAM_USE_AEC | ALGORITHM_STREAM_USE_AGC | ALGORITHM_STREAM_USE_NS),
-      // .algo_mask = (ALGORITHM_STREAM_USE_AGC | ALGORITHM_STREAM_USE_NS),
-      .algo_mask = (ALGORITHM_STREAM_USE_AEC | ALGORITHM_STREAM_USE_NS),
-      // .algo_mask = (ALGORITHM_STREAM_USE_NS),
-      .sample_rate = 16000,
-      .mic_ch = 1,
-      .agc_gain = 10,
-      .aec_low_cost = false,
-  };
-
-  // audio_element_handle_t algo_stream = algo_stream_init(&algo_cfg);
-
-  raw_stream_cfg_t raw_cfg = {
-      .type = AUDIO_STREAM_READER,
-      .out_rb_size = 8 * 1024,
-  };
-  audio_element_handle_t raw_read = raw_stream_init(&raw_cfg);
-
-  audio_pipeline_register(pipeline, i2s_stream_reader, "i2s");
-  audio_pipeline_register(pipeline, filter, "filter");
-  // audio_pipeline_register(pipeline, algo_stream, "algo");
-  audio_pipeline_register(pipeline, raw_read, "raw");
-
-  const char *link_tag[4] = {
-      "i2s",
-      "filter",
-      // "algo",
-      "raw",
-  };
-  audio_pipeline_link(pipeline, &link_tag[0], 3);
-
-  audio_pipeline_run(pipeline);
-
-  event.type = TaskEventType::STARTED;
-  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-  CommandEvent command_event;
-
-  while (true) {
-    if (xQueueReceive(this_mic->read_command_queue_, &command_event, 0) == pdTRUE) {
-      if (command_event.stop) {
-        // Stop signal from main thread
-        break;
-      }
-    }
-
-    int bytes_read = raw_stream_read(raw_read, (char *) buffer, BUFFER_SIZE);
-
-    if (bytes_read == -2 || bytes_read == 0) {
-      // No data in buffers to read.
-      continue;
-    } else if (bytes_read < 0) {
-      event.type = TaskEventType::WARNING;
-      event.err = bytes_read;
-      xQueueSend(this_mic->read_event_queue_, &event, 0);
-      continue;
-    }
-
-    event.type = TaskEventType::RUNNING;
-    event.err = bytes_read;
-    xQueueSend(this_mic->read_event_queue_, &event, 0);
-
-    int available = rb_bytes_available(this_mic->ring_buffer_);
-    if (available < bytes_read) {
-      rb_read(this_mic->ring_buffer_, nullptr, bytes_read - available, 0);
-    }
-    rb_write(this_mic->ring_buffer_, (char *) buffer, bytes_read, 0);
-  }
-
-  allocator.deallocate(buffer, BUFFER_SIZE / sizeof(int16_t));
-
-  audio_pipeline_stop(pipeline);
-  audio_pipeline_wait_for_stop(pipeline);
-  audio_pipeline_terminate(pipeline);
-
-  event.type = TaskEventType::STOPPING;
-  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-  audio_pipeline_unregister(pipeline, i2s_stream_reader);
-  audio_pipeline_unregister(pipeline, filter);
-  // audio_pipeline_unregister(pipeline, algo_stream);
-  audio_pipeline_unregister(pipeline, raw_read);
-
-  audio_pipeline_deinit(pipeline);
-  audio_element_deinit(i2s_stream_reader);
-  audio_element_deinit(filter);
-  // audio_element_deinit(algo_stream);
-  audio_element_deinit(raw_read);
-
-  event.type = TaskEventType::STOPPED;
-  xQueueSend(this_mic->read_event_queue_, &event, portMAX_DELAY);
-
-  while (true) {
-    delay(10);
-  }
-}
-
-void ESPADFMicrophone::stop() {
-  if (this->state_ == microphone::STATE_STOPPED || this->state_ == microphone::STATE_STOPPING || this->is_failed())
-    return;
-  this->state_ = microphone::STATE_STOPPING;
-  CommandEvent command_event;
-  command_event.stop = true;
-  xQueueSendToFront(this->read_command_queue_, &command_event, portMAX_DELAY);
-  ESP_LOGD(TAG, "Stopping microphone");
-}
-
-size_t ESPADFMicrophone::read(int16_t *buf, size_t len) {
-  if (rb_bytes_available(this->ring_buffer_) == 0) {
-    return 0;  // No data
-  }
-  int bytes_read = rb_read(this->ring_buffer_, (char *) buf, len, 0);
-
-  if (bytes_read == -4 || bytes_read == -2 || bytes_read == 0) {
-    // No data in buffers to read.
-    return 0;
-  } else if (bytes_read < 0) {
-    ESP_LOGW(TAG, "Error reading from I2S microphone %s (%d)", esp_err_to_name(bytes_read), bytes_read);
-    this->status_set_warning();
-    return 0;
-  }
-  this->status_clear_warning();
-
-  return bytes_read;
-}
-
-void ESPADFMicrophone::read_() {
-  std::vector<int16_t> samples;
-  samples.resize(BUFFER_SIZE);
-  this->read(samples.data(), samples.size());
-
-  this->data_callbacks_.call(samples);
-}
-
-void ESPADFMicrophone::watch_() {
-  TaskEvent event;
-  if (xQueueReceive(this->read_event_queue_, &event, 0) == pdTRUE) {
-    switch (event.type) {
-      case TaskEventType::STARTING:
-      case TaskEventType::STOPPING:
-        break;
-      case TaskEventType::STARTED:
-        ESP_LOGD(TAG, "Microphone started");
-        this->state_ = microphone::STATE_RUNNING;
-        break;
-      case TaskEventType::RUNNING:
-        this->status_clear_warning();
-        // ESP_LOGD(TAG, "Putting %d bytes into ring buffer", event.err);
-        break;
-      case TaskEventType::STOPPED:
-        this->parent_->unlock();
-        this->state_ = microphone::STATE_STOPPED;
-        vTaskDelete(this->read_task_handle_);
-        this->read_task_handle_ = nullptr;
-        ESP_LOGD(TAG, "Microphone stopped");
-        break;
-      case TaskEventType::WARNING:
-        ESP_LOGW(TAG, "Error writing to pipeline: %s", esp_err_to_name(event.err));
-        this->status_set_warning();
-        break;
-    }
-  }
-}
-
-void ESPADFMicrophone::loop() {
-  this->watch_();
-  switch (this->state_) {
-    case microphone::STATE_STOPPED:
-    case microphone::STATE_STOPPING:
-      break;
-    case microphone::STATE_STARTING:
-      this->start_();
-      break;
-    case microphone::STATE_RUNNING:
-      if (this->data_callbacks_.size() > 0) {
-        this->read_();
-      }
-      break;
-  }
-}
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/esp_adf/microphone/esp_adf_microphone.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP_IDF
-
-#include "../esp_adf.h"
-
-#include "esphome/components/microphone/microphone.h"
-#include "esphome/core/component.h"
-
-#include <ringbuf.h>
-
-namespace esphome {
-namespace esp_adf {
-
-class ESPADFMicrophone : public ESPADFPipeline, public microphone::Microphone, public Component {
- public:
-  void setup() override;
-  void start() override;
-  void stop() override;
-
-  void loop() override;
-
-  size_t read(int16_t *buf, size_t len) override;
-
- protected:
-  void start_();
-  void read_();
-  void watch_();
-
-  static void read_task(void *params);
-
-  ringbuf_handle_t ring_buffer_;
-
-  TaskHandle_t read_task_handle_{nullptr};
-  QueueHandle_t read_event_queue_;
-  QueueHandle_t read_command_queue_;
-};
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/esp_adf/speaker/__init__.py

@@ -1,41 +0,0 @@
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.components import speaker
-from esphome.const import CONF_ID
-
-from .. import (
-    CONF_ESP_ADF_ID,
-    ESPADF,
-    ESPADFPipeline,
-    esp_adf_ns,
-    final_validate_usable_board,
-)
-
-AUTO_LOAD = ["esp_adf"]
-CONFLICTS_WITH = ["i2s_audio"]
-DEPENDENCIES = ["esp32"]
-
-ESPADFSpeaker = esp_adf_ns.class_(
-    "ESPADFSpeaker", ESPADFPipeline, speaker.Speaker, cg.Component
-)
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ESPADFSpeaker),
-            cv.GenerateID(CONF_ESP_ADF_ID): cv.use_id(ESPADF),
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_with_esp_idf,
-)
-
-FINAL_VALIDATE_SCHEMA = final_validate_usable_board("speaker")
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await cg.register_parented(var, config[CONF_ESP_ADF_ID])
-
-    await speaker.register_speaker(var, config)

esphome/components/esp_adf/speaker/esp_adf_speaker.cpp

@@ -1,274 +0,0 @@
-#include "esp_adf_speaker.h"
-
-#ifdef USE_ESP_IDF
-
-#include <driver/i2s.h>
-
-#include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <audio_hal.h>
-#include <filter_resample.h>
-#include <i2s_stream.h>
-#include <raw_stream.h>
-
-namespace esphome {
-namespace esp_adf {
-
-static const size_t BUFFER_COUNT = 50;
-
-static const char *const TAG = "esp_adf.speaker";
-
-void ESPADFSpeaker::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP ADF Speaker...");
-
-  this->buffer_queue_ = xQueueCreate(BUFFER_COUNT, sizeof(DataEvent));
-  this->event_queue_ = xQueueCreate(20, sizeof(TaskEvent));
-}
-
-void ESPADFSpeaker::start() { this->state_ = speaker::STATE_STARTING; }
-void ESPADFSpeaker::start_() {
-  if (!this->parent_->try_lock()) {
-    return;  // Waiting for another i2s component to return lock
-  }
-
-  xTaskCreate(ESPADFSpeaker::player_task, "speaker_task", 8192, (void *) this, 0, &this->player_task_handle_);
-}
-
-void ESPADFSpeaker::player_task(void *params) {
-  ESPADFSpeaker *this_speaker = (ESPADFSpeaker *) params;
-
-  TaskEvent event;
-  event.type = TaskEventType::STARTING;
-  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
-
-  i2s_driver_config_t i2s_config = {
-      .mode = (i2s_mode_t) (I2S_MODE_MASTER | I2S_MODE_TX),
-      .sample_rate = 16000,
-      .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
-      .channel_format = I2S_CHANNEL_FMT_ONLY_RIGHT,
-      .communication_format = I2S_COMM_FORMAT_STAND_I2S,
-      .intr_alloc_flags = ESP_INTR_FLAG_LEVEL2 | ESP_INTR_FLAG_IRAM,
-      .dma_buf_count = 8,
-      .dma_buf_len = 1024,
-      .use_apll = false,
-      .tx_desc_auto_clear = true,
-      .fixed_mclk = 0,
-      .mclk_multiple = I2S_MCLK_MULTIPLE_256,
-      .bits_per_chan = I2S_BITS_PER_CHAN_DEFAULT,
-  };
-
-  audio_pipeline_cfg_t pipeline_cfg = {
-      .rb_size = 8 * 1024,
-  };
-  audio_pipeline_handle_t pipeline = audio_pipeline_init(&pipeline_cfg);
-
-  i2s_stream_cfg_t i2s_cfg = {
-      .type = AUDIO_STREAM_WRITER,
-      .i2s_config = i2s_config,
-      .i2s_port = I2S_NUM_0,
-      .use_alc = false,
-      .volume = 0,
-      .out_rb_size = I2S_STREAM_RINGBUFFER_SIZE,
-      .task_stack = I2S_STREAM_TASK_STACK,
-      .task_core = I2S_STREAM_TASK_CORE,
-      .task_prio = I2S_STREAM_TASK_PRIO,
-      .stack_in_ext = false,
-      .multi_out_num = 0,
-      .uninstall_drv = true,
-      .need_expand = false,
-      .expand_src_bits = I2S_BITS_PER_SAMPLE_16BIT,
-  };
-  audio_element_handle_t i2s_stream_writer = i2s_stream_init(&i2s_cfg);
-
-  rsp_filter_cfg_t rsp_cfg = {
-      .src_rate = 16000,
-      .src_ch = 1,
-      .dest_rate = 16000,
-      .dest_bits = 16,
-      .dest_ch = 2,
-      .src_bits = 16,
-      .mode = RESAMPLE_DECODE_MODE,
-      .max_indata_bytes = RSP_FILTER_BUFFER_BYTE,
-      .out_len_bytes = RSP_FILTER_BUFFER_BYTE,
-      .type = ESP_RESAMPLE_TYPE_AUTO,
-      .complexity = 2,
-      .down_ch_idx = 0,
-      .prefer_flag = ESP_RSP_PREFER_TYPE_SPEED,
-      .out_rb_size = RSP_FILTER_RINGBUFFER_SIZE,
-      .task_stack = RSP_FILTER_TASK_STACK,
-      .task_core = RSP_FILTER_TASK_CORE,
-      .task_prio = RSP_FILTER_TASK_PRIO,
-      .stack_in_ext = true,
-  };
-  audio_element_handle_t filter = rsp_filter_init(&rsp_cfg);
-
-  raw_stream_cfg_t raw_cfg = {
-      .type = AUDIO_STREAM_WRITER,
-      .out_rb_size = 8 * 1024,
-  };
-  audio_element_handle_t raw_write = raw_stream_init(&raw_cfg);
-
-  audio_pipeline_register(pipeline, raw_write, "raw");
-  audio_pipeline_register(pipeline, filter, "filter");
-  audio_pipeline_register(pipeline, i2s_stream_writer, "i2s");
-
-  const char *link_tag[3] = {
-      "raw",
-      // "filter",
-      "i2s",
-  };
-  audio_pipeline_link(pipeline, &link_tag[0], 2);
-
-  audio_pipeline_run(pipeline);
-
-  DataEvent data_event;
-
-  event.type = TaskEventType::STARTED;
-  xQueueSend(this_speaker->event_queue_, &event, 0);
-
-  uint32_t last_received = millis();
-
-  while (true) {
-    if (xQueueReceive(this_speaker->buffer_queue_, &data_event, 0) != pdTRUE) {
-      if (millis() - last_received > 500) {
-        // No audio for 500ms, stop
-        break;
-      } else {
-        continue;
-      }
-    }
-    if (data_event.stop) {
-      // Stop signal from main thread
-      while (xQueueReceive(this_speaker->buffer_queue_, &data_event, 0) == pdTRUE) {
-        // Flush queue
-      }
-      break;
-    }
-
-    size_t remaining = data_event.len;
-    size_t current = 0;
-    if (remaining > 0)
-      last_received = millis();
-
-    while (remaining > 0) {
-      int bytes_written = raw_stream_write(raw_write, (char *) data_event.data + current, remaining);
-      if (bytes_written == ESP_FAIL) {
-        event = {.type = TaskEventType::WARNING, .err = ESP_FAIL};
-        xQueueSend(this_speaker->event_queue_, &event, 0);
-        continue;
-      }
-
-      remaining -= bytes_written;
-      current += bytes_written;
-    }
-
-    event.type = TaskEventType::RUNNING;
-    xQueueSend(this_speaker->event_queue_, &event, 0);
-  }
-
-  audio_pipeline_stop(pipeline);
-  audio_pipeline_wait_for_stop(pipeline);
-  audio_pipeline_terminate(pipeline);
-
-  event.type = TaskEventType::STOPPING;
-  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
-
-  audio_pipeline_unregister(pipeline, i2s_stream_writer);
-  audio_pipeline_unregister(pipeline, filter);
-  audio_pipeline_unregister(pipeline, raw_write);
-
-  audio_pipeline_deinit(pipeline);
-  audio_element_deinit(i2s_stream_writer);
-  audio_element_deinit(filter);
-  audio_element_deinit(raw_write);
-
-  event.type = TaskEventType::STOPPED;
-  xQueueSend(this_speaker->event_queue_, &event, portMAX_DELAY);
-
-  while (true) {
-    delay(10);
-  }
-}
-
-void ESPADFSpeaker::stop() {
-  if (this->state_ == speaker::STATE_STOPPED)
-    return;
-  if (this->state_ == speaker::STATE_STARTING) {
-    this->state_ = speaker::STATE_STOPPED;
-    return;
-  }
-  this->state_ = speaker::STATE_STOPPING;
-  DataEvent data;
-  data.stop = true;
-  xQueueSendToFront(this->buffer_queue_, &data, portMAX_DELAY);
-}
-
-void ESPADFSpeaker::watch_() {
-  TaskEvent event;
-  if (xQueueReceive(this->event_queue_, &event, 0) == pdTRUE) {
-    switch (event.type) {
-      case TaskEventType::STARTING:
-      case TaskEventType::STOPPING:
-        break;
-      case TaskEventType::STARTED:
-        this->state_ = speaker::STATE_RUNNING;
-        break;
-      case TaskEventType::RUNNING:
-        this->status_clear_warning();
-        break;
-      case TaskEventType::STOPPED:
-        this->parent_->unlock();
-        this->state_ = speaker::STATE_STOPPED;
-        vTaskDelete(this->player_task_handle_);
-        this->player_task_handle_ = nullptr;
-        break;
-      case TaskEventType::WARNING:
-        ESP_LOGW(TAG, "Error writing to pipeline: %s", esp_err_to_name(event.err));
-        this->status_set_warning();
-        break;
-    }
-  }
-}
-
-void ESPADFSpeaker::loop() {
-  this->watch_();
-  switch (this->state_) {
-    case speaker::STATE_STARTING:
-      this->start_();
-      break;
-    case speaker::STATE_RUNNING:
-    case speaker::STATE_STOPPING:
-    case speaker::STATE_STOPPED:
-      break;
-  }
-}
-
-size_t ESPADFSpeaker::play(const uint8_t *data, size_t length) {
-  if (this->state_ != speaker::STATE_RUNNING && this->state_ != speaker::STATE_STARTING) {
-    this->start();
-  }
-  size_t remaining = length;
-  size_t index = 0;
-  while (remaining > 0) {
-    DataEvent event;
-    event.stop = false;
-    size_t to_send_length = std::min(remaining, BUFFER_SIZE);
-    event.len = to_send_length;
-    memcpy(event.data, data + index, to_send_length);
-    if (xQueueSend(this->buffer_queue_, &event, 0) != pdTRUE) {
-      return index;  // Queue full
-    }
-    remaining -= to_send_length;
-    index += to_send_length;
-  }
-  return index;
-}
-
-bool ESPADFSpeaker::has_buffered_data() const { return uxQueueMessagesWaiting(this->buffer_queue_) > 0; }
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/esp_adf/speaker/esp_adf_speaker.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP_IDF
-
-#include "../esp_adf.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/queue.h>
-
-#include "esphome/components/speaker/speaker.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-#include <audio_element.h>
-#include <audio_pipeline.h>
-
-namespace esphome {
-namespace esp_adf {
-
-class ESPADFSpeaker : public ESPADFPipeline, public speaker::Speaker, public Component {
- public:
-  float get_setup_priority() const override { return esphome::setup_priority::LATE; }
-
-  void setup() override;
-  void loop() override;
-
-  void start() override;
-  void stop() override;
-
-  size_t play(const uint8_t *data, size_t length) override;
-
-  bool has_buffered_data() const override;
-
- protected:
-  void start_();
-  void watch_();
-
-  static void player_task(void *params);
-
-  TaskHandle_t player_task_handle_{nullptr};
-  QueueHandle_t buffer_queue_;
-  QueueHandle_t event_queue_;
-};
-
-}  // namespace esp_adf
-}  // namespace esphome
-
-#endif  // USE_ESP_IDF

esphome/components/fan/__init__.py

@@ -18,6 +18,7 @@ from esphome.const import (
     CONF_ON_SPEED_SET,
     CONF_ON_TURN_OFF,
     CONF_ON_TURN_ON,
+    CONF_ON_PRESET_SET,
     CONF_TRIGGER_ID,
     CONF_DIRECTION,
     CONF_RESTORE_MODE,
@@ -57,6 +58,9 @@ CycleSpeedAction = fan_ns.class_("CycleSpeedAction", automation.Action)
 FanTurnOnTrigger = fan_ns.class_("FanTurnOnTrigger", automation.Trigger.template())
 FanTurnOffTrigger = fan_ns.class_("FanTurnOffTrigger", automation.Trigger.template())
 FanSpeedSetTrigger = fan_ns.class_("FanSpeedSetTrigger", automation.Trigger.template())
+FanPresetSetTrigger = fan_ns.class_(
+    "FanPresetSetTrigger", automation.Trigger.template()
+)
 
 FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
 FanIsOffCondition = fan_ns.class_("FanIsOffCondition", automation.Condition.template())
@@ -101,9 +105,46 @@ FAN_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).exte
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FanSpeedSetTrigger),
             }
         ),
+        cv.Optional(CONF_ON_PRESET_SET): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(FanPresetSetTrigger),
+            }
+        ),
     }
 )
 
+_PRESET_MODES_SCHEMA = cv.All(
+    cv.ensure_list(cv.string_strict),
+    cv.Length(min=1),
+)
+
+
+def validate_preset_modes(value):
+    # Check against defined schema
+    value = _PRESET_MODES_SCHEMA(value)
+
+    # Ensure preset names are unique
+    errors = []
+    presets = set()
+    for i, preset in enumerate(value):
+        # If name does not exist yet add it
+        if preset not in presets:
+            presets.add(preset)
+            continue
+
+        # Otherwise it's an error
+        errors.append(
+            cv.Invalid(
+                f"Found duplicate preset name '{preset}'. Presets must have unique names.",
+                [i],
+            )
+        )
+
+    if errors:
+        raise cv.MultipleInvalid(errors)
+
+    return value
+
 
 async def setup_fan_core_(var, config):
     await setup_entity(var, config)
@@ -154,6 +195,9 @@ async def setup_fan_core_(var, config):
     for conf in config.get(CONF_ON_SPEED_SET, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_PRESET_SET, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
 
 
 async def register_fan(var, config):

esphome/components/fan/automation.h

@@ -165,5 +165,23 @@ class FanSpeedSetTrigger : public Trigger<> {
   int last_speed_;
 };
 
+class FanPresetSetTrigger : public Trigger<> {
+ public:
+  FanPresetSetTrigger(Fan *state) {
+    state->add_on_state_callback([this, state]() {
+      auto preset_mode = state->preset_mode;
+      auto should_trigger = preset_mode != this->last_preset_mode_;
+      this->last_preset_mode_ = preset_mode;
+      if (should_trigger) {
+        this->trigger();
+      }
+    });
+    this->last_preset_mode_ = state->preset_mode;
+  }
+
+ protected:
+  std::string last_preset_mode_;
+};
+
 }  // namespace fan
 }  // namespace esphome

esphome/components/fan/fan.cpp

@@ -32,9 +32,12 @@ void FanCall::perform() {
   if (this->direction_.has_value()) {
     ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(*this->direction_)));
   }
-
+  if (!this->preset_mode_.empty()) {
+    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode_.c_str());
+  }
   this->parent_.control(*this);
 }
+
 void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
@@ -62,6 +65,15 @@ void FanCall::validate_() {
     ESP_LOGW(TAG, "'%s' - This fan does not support directions!", this->parent_.get_name().c_str());
     this->direction_.reset();
   }
+
+  if (!this->preset_mode_.empty()) {
+    const auto &preset_modes = traits.supported_preset_modes();
+    if (preset_modes.find(this->preset_mode_) == preset_modes.end()) {
+      ESP_LOGW(TAG, "'%s' - This fan does not support preset mode '%s'!", this->parent_.get_name().c_str(),
+               this->preset_mode_.c_str());
+      this->preset_mode_.clear();
+    }
+  }
 }
 
 FanCall FanRestoreState::to_call(Fan &fan) {
@@ -70,6 +82,14 @@ FanCall FanRestoreState::to_call(Fan &fan) {
   call.set_oscillating(this->oscillating);
   call.set_speed(this->speed);
   call.set_direction(this->direction);
+
+  if (fan.get_traits().supports_preset_modes()) {
+    // Use stored preset index to get preset name
+    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    if (this->preset_mode < preset_modes.size()) {
+      call.set_preset_mode(*std::next(preset_modes.begin(), this->preset_mode));
+    }
+  }
   return call;
 }
 void FanRestoreState::apply(Fan &fan) {
@@ -77,6 +97,14 @@ void FanRestoreState::apply(Fan &fan) {
   fan.oscillating = this->oscillating;
   fan.speed = this->speed;
   fan.direction = this->direction;
+
+  if (fan.get_traits().supports_preset_modes()) {
+    // Use stored preset index to get preset name
+    const auto &preset_modes = fan.get_traits().supported_preset_modes();
+    if (this->preset_mode < preset_modes.size()) {
+      fan.preset_mode = *std::next(preset_modes.begin(), this->preset_mode);
+    }
+  }
   fan.publish_state();
 }
 
@@ -100,7 +128,9 @@ void Fan::publish_state() {
   if (traits.supports_direction()) {
     ESP_LOGD(TAG, "  Direction: %s", LOG_STR_ARG(fan_direction_to_string(this->direction)));
   }
-
+  if (traits.supports_preset_modes() && !this->preset_mode.empty()) {
+    ESP_LOGD(TAG, "  Preset Mode: %s", this->preset_mode.c_str());
+  }
   this->state_callback_.call();
   this->save_state_();
 }
@@ -143,20 +173,36 @@ void Fan::save_state_() {
   state.oscillating = this->oscillating;
   state.speed = this->speed;
   state.direction = this->direction;
+
+  if (this->get_traits().supports_preset_modes() && !this->preset_mode.empty()) {
+    const auto &preset_modes = this->get_traits().supported_preset_modes();
+    // Store index of current preset mode
+    auto preset_iterator = preset_modes.find(this->preset_mode);
+    if (preset_iterator != preset_modes.end())
+      state.preset_mode = std::distance(preset_modes.begin(), preset_iterator);
+  }
+
   this->rtc_.save(&state);
 }
 
 void Fan::dump_traits_(const char *tag, const char *prefix) {
-  if (this->get_traits().supports_speed()) {
+  auto traits = this->get_traits();
+
+  if (traits.supports_speed()) {
     ESP_LOGCONFIG(tag, "%s  Speed: YES", prefix);
-    ESP_LOGCONFIG(tag, "%s  Speed count: %d", prefix, this->get_traits().supported_speed_count());
+    ESP_LOGCONFIG(tag, "%s  Speed count: %d", prefix, traits.supported_speed_count());
   }
-  if (this->get_traits().supports_oscillation()) {
+  if (traits.supports_oscillation()) {
     ESP_LOGCONFIG(tag, "%s  Oscillation: YES", prefix);
   }
-  if (this->get_traits().supports_direction()) {
+  if (traits.supports_direction()) {
     ESP_LOGCONFIG(tag, "%s  Direction: YES", prefix);
   }
+  if (traits.supports_preset_modes()) {
+    ESP_LOGCONFIG(tag, "%s  Supported presets:", prefix);
+    for (const std::string &s : traits.supported_preset_modes())
+      ESP_LOGCONFIG(tag, "%s    - %s", prefix, s.c_str());
+  }
 }
 
 }  // namespace fan

esphome/components/fan/fan.h

@@ -72,6 +72,11 @@ class FanCall {
     return *this;
   }
   optional<FanDirection> get_direction() const { return this->direction_; }
+  FanCall &set_preset_mode(const std::string &preset_mode) {
+    this->preset_mode_ = preset_mode;
+    return *this;
+  }
+  std::string get_preset_mode() const { return this->preset_mode_; }
 
   void perform();
 
@@ -83,6 +88,7 @@ class FanCall {
   optional<bool> oscillating_;
   optional<int> speed_;
   optional<FanDirection> direction_{};
+  std::string preset_mode_{};
 };
 
 struct FanRestoreState {
@@ -90,6 +96,7 @@ struct FanRestoreState {
   int speed;
   bool oscillating;
   FanDirection direction;
+  uint8_t preset_mode;
 
   /// Convert this struct to a fan call that can be performed.
   FanCall to_call(Fan &fan);
@@ -107,6 +114,8 @@ class Fan : public EntityBase {
   int speed{0};
   /// The current direction of the fan
   FanDirection direction{FanDirection::FORWARD};
+  // The current preset mode of the fan
+  std::string preset_mode{};
 
   FanCall turn_on();
   FanCall turn_off();

esphome/components/fan/fan_traits.h

@@ -1,3 +1,6 @@
+#include <set>
+#include <utility>
+
 #pragma once
 
 namespace esphome {
@@ -25,12 +28,19 @@ class FanTraits {
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
   void set_direction(bool direction) { this->direction_ = direction; }
+  /// Return the preset modes supported by the fan.
+  std::set<std::string> supported_preset_modes() const { return this->preset_modes_; }
+  /// Set the preset modes supported by the fan.
+  void set_supported_preset_modes(const std::set<std::string> &preset_modes) { this->preset_modes_ = preset_modes; }
+  /// Return if preset modes are supported
+  bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
  protected:
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
   int speed_count_{};
+  std::set<std::string> preset_modes_{};
 };
 
 }  // namespace fan

esphome/components/font/__init__.py

@@ -67,13 +67,13 @@ def validate_pillow_installed(value):
     except ImportError as err:
         raise cv.Invalid(
             "Please install the pillow python package to use this feature. "
-            '(pip install "pillow==10.0.1")'
+            '(pip install "pillow==10.1.0")'
         ) from err
 
-    if version.parse(PIL.__version__) != version.parse("10.0.1"):
+    if version.parse(PIL.__version__) != version.parse("10.1.0"):
         raise cv.Invalid(
-            "Please update your pillow installation to 10.0.1. "
-            '(pip install "pillow==10.0.1")'
+            "Please update your pillow installation to 10.1.0. "
+            '(pip install "pillow==10.1.0")'
         )
 
     return value

esphome/components/ft5x06/__init__.py

@@ -0,0 +1,6 @@
+import esphome.codegen as cg
+
+CODEOWNERS = ["@clydebarrow"]
+DEPENDENCIES = ["i2c"]
+
+ft5x06_ns = cg.esphome_ns.namespace("ft5x06")

esphome/components/ft5x06/touchscreen/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+
+from esphome.components import i2c, touchscreen
+from esphome.const import CONF_ID
+from .. import ft5x06_ns
+
+FT5x06ButtonListener = ft5x06_ns.class_("FT5x06ButtonListener")
+FT5x06Touchscreen = ft5x06_ns.class_(
+    "FT5x06Touchscreen",
+    touchscreen.Touchscreen,
+    cg.Component,
+    i2c.I2CDevice,
+)
+
+CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(FT5x06Touchscreen),
+    }
+).extend(i2c.i2c_device_schema(0x48))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await i2c.register_i2c_device(var, config)
+    await touchscreen.register_touchscreen(var, config)

esphome/components/ft5x06/touchscreen/ft5x06_touchscreen.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/touchscreen/touchscreen.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace ft5x06 {
+
+static const char *const TAG = "ft5x06.touchscreen";
+
+enum VendorId {
+  FT5X06_ID_UNKNOWN = 0,
+  FT5X06_ID_1 = 0x51,
+  FT5X06_ID_2 = 0x11,
+  FT5X06_ID_3 = 0xCD,
+};
+
+enum FTCmd : uint8_t {
+  FT5X06_MODE_REG = 0x00,
+  FT5X06_ORIGIN_REG = 0x08,
+  FT5X06_RESOLUTION_REG = 0x0C,
+  FT5X06_VENDOR_ID_REG = 0xA8,
+  FT5X06_TD_STATUS = 0x02,
+  FT5X06_TOUCH_DATA = 0x03,
+  FT5X06_I_MODE = 0xA4,
+  FT5X06_TOUCH_MAX = 0x4C,
+};
+
+enum FTMode : uint8_t {
+  FT5X06_OP_MODE = 0,
+  FT5X06_SYSINFO_MODE = 0x10,
+  FT5X06_TEST_MODE = 0x40,
+};
+
+static const size_t MAX_TOUCHES = 5;  // max number of possible touches reported
+
+class FT5x06Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
+ public:
+  void setup() override {
+    esph_log_config(TAG, "Setting up FT5x06 Touchscreen...");
+    // wait 200ms after reset.
+    this->set_timeout(200, [this] { this->continue_setup_(); });
+  }
+
+  void continue_setup_(void) {
+    uint8_t data[4];
+    if (!this->set_mode_(FT5X06_OP_MODE))
+      return;
+
+    if (!this->err_check_(this->read_register(FT5X06_VENDOR_ID_REG, data, 1), "Read Vendor ID"))
+      return;
+    switch (data[0]) {
+      case FT5X06_ID_1:
+      case FT5X06_ID_2:
+      case FT5X06_ID_3:
+        this->vendor_id_ = (VendorId) data[0];
+        esph_log_d(TAG, "Read vendor ID 0x%X", data[0]);
+        break;
+
+      default:
+        esph_log_e(TAG, "Unknown vendor ID 0x%X", data[0]);
+        this->mark_failed();
+        return;
+    }
+    // reading the chip registers to get max x/y does not seem to work.
+    this->x_raw_max_ = this->display_->get_width();
+    this->y_raw_max_ = this->display_->get_height();
+    esph_log_config(TAG, "FT5x06 Touchscreen setup complete");
+  }
+
+  void update_touches() override {
+    uint8_t touch_cnt;
+    uint8_t data[MAX_TOUCHES][6];
+
+    if (!this->read_byte(FT5X06_TD_STATUS, &touch_cnt) || touch_cnt > MAX_TOUCHES) {
+      esph_log_w(TAG, "Failed to read status");
+      return;
+    }
+    if (touch_cnt == 0)
+      return;
+
+    if (!this->read_bytes(FT5X06_TOUCH_DATA, (uint8_t *) data, touch_cnt * 6)) {
+      esph_log_w(TAG, "Failed to read touch data");
+      return;
+    }
+    for (uint8_t i = 0; i != touch_cnt; i++) {
+      uint8_t status = data[i][0] >> 6;
+      uint8_t id = data[i][2] >> 3;
+      uint16_t x = encode_uint16(data[i][0] & 0x0F, data[i][1]);
+      uint16_t y = encode_uint16(data[i][2] & 0xF, data[i][3]);
+
+      esph_log_d(TAG, "Read %X status, id: %d, pos %d/%d", status, id, x, y);
+      if (status == 0 || status == 2) {
+        this->add_raw_touch_position_(id, x, y);
+      }
+    }
+  }
+
+  void dump_config() override {
+    esph_log_config(TAG, "FT5x06 Touchscreen:");
+    esph_log_config(TAG, "  Address: 0x%02X", this->address_);
+    esph_log_config(TAG, "  Vendor ID: 0x%X", (int) this->vendor_id_);
+  }
+
+ protected:
+  bool err_check_(i2c::ErrorCode err, const char *msg) {
+    if (err != i2c::ERROR_OK) {
+      this->mark_failed();
+      esph_log_e(TAG, "%s failed - err 0x%X", msg, err);
+      return false;
+    }
+    return true;
+  }
+  bool set_mode_(FTMode mode) {
+    return this->err_check_(this->write_register(FT5X06_MODE_REG, (uint8_t *) &mode, 1), "Set mode");
+  }
+  VendorId vendor_id_{FT5X06_ID_UNKNOWN};
+};
+
+}  // namespace ft5x06
+}  // namespace esphome

esphome/components/ft63x6/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@gpambrozio"]

esphome/components/ft63x6/ft63x6.cpp

@@ -0,0 +1,99 @@
+/**************************************************************************/
+/*!
+  Author: Gustavo Ambrozio
+  Based on work by: Atsushi Sasaki (https://github.com/aselectroworks/Arduino-FT6336U)
+*/
+/**************************************************************************/
+
+#include "ft63x6.h"
+#include "esphome/core/log.h"
+
+// Registers
+// Reference: https://focuslcds.com/content/FT6236.pdf
+namespace esphome {
+namespace ft63x6 {
+
+static const uint8_t FT63X6_ADDR_TOUCH_COUNT = 0x02;
+
+static const uint8_t FT63X6_ADDR_TOUCH1_ID = 0x05;
+static const uint8_t FT63X6_ADDR_TOUCH1_X = 0x03;
+static const uint8_t FT63X6_ADDR_TOUCH1_Y = 0x05;
+
+static const uint8_t FT63X6_ADDR_TOUCH2_ID = 0x0B;
+static const uint8_t FT63X6_ADDR_TOUCH2_X = 0x09;
+static const uint8_t FT63X6_ADDR_TOUCH2_Y = 0x0B;
+
+static const char *const TAG = "FT63X6Touchscreen";
+
+void FT63X6Touchscreen::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up FT63X6Touchscreen Touchscreen...");
+  if (this->interrupt_pin_ != nullptr) {
+    this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
+    this->interrupt_pin_->setup();
+    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
+  }
+
+  if (this->reset_pin_ != nullptr) {
+    this->reset_pin_->setup();
+  }
+
+  this->hard_reset_();
+
+  // Get touch resolution
+  this->x_raw_max_ = 320;
+  this->y_raw_max_ = 480;
+}
+
+void FT63X6Touchscreen::update_touches() {
+  int touch_count = this->read_touch_count_();
+  if (touch_count == 0) {
+    return;
+  }
+
+  uint8_t touch_id = this->read_touch_id_(FT63X6_ADDR_TOUCH1_ID);  // id1 = 0 or 1
+  int16_t x = this->read_touch_coordinate_(FT63X6_ADDR_TOUCH1_X);
+  int16_t y = this->read_touch_coordinate_(FT63X6_ADDR_TOUCH1_Y);
+  this->add_raw_touch_position_(touch_id, x, y);
+
+  if (touch_count >= 2) {
+    touch_id = this->read_touch_id_(FT63X6_ADDR_TOUCH2_ID);  // id2 = 0 or 1(~id1 & 0x01)
+    x = this->read_touch_coordinate_(FT63X6_ADDR_TOUCH2_X);
+    y = this->read_touch_coordinate_(FT63X6_ADDR_TOUCH2_Y);
+    this->add_raw_touch_position_(touch_id, x, y);
+  }
+}
+
+void FT63X6Touchscreen::hard_reset_() {
+  if (this->reset_pin_ != nullptr) {
+    this->reset_pin_->digital_write(false);
+    delay(10);
+    this->reset_pin_->digital_write(true);
+  }
+}
+
+void FT63X6Touchscreen::dump_config() {
+  ESP_LOGCONFIG(TAG, "FT63X6 Touchscreen:");
+  LOG_I2C_DEVICE(this);
+  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
+  LOG_PIN("  Reset Pin: ", this->reset_pin_);
+}
+
+uint8_t FT63X6Touchscreen::read_touch_count_() { return this->read_byte_(FT63X6_ADDR_TOUCH_COUNT); }
+
+// Touch functions
+uint16_t FT63X6Touchscreen::read_touch_coordinate_(uint8_t coordinate) {
+  uint8_t read_buf[2];
+  read_buf[0] = this->read_byte_(coordinate);
+  read_buf[1] = this->read_byte_(coordinate + 1);
+  return ((read_buf[0] & 0x0f) << 8) | read_buf[1];
+}
+uint8_t FT63X6Touchscreen::read_touch_id_(uint8_t id_address) { return this->read_byte_(id_address) >> 4; }
+
+uint8_t FT63X6Touchscreen::read_byte_(uint8_t addr) {
+  uint8_t byte = 0;
+  this->read_byte(addr, &byte);
+  return byte;
+}
+
+}  // namespace ft63x6
+}  // namespace esphome

esphome/components/ft63x6/ft63x6.h

@@ -0,0 +1,41 @@
+/**************************************************************************/
+/*!
+  Author: Gustavo Ambrozio
+  Based on work by: Atsushi Sasaki (https://github.com/aselectroworks/Arduino-FT6336U)
+*/
+/**************************************************************************/
+
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/touchscreen/touchscreen.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace ft63x6 {
+
+using namespace touchscreen;
+
+class FT63X6Touchscreen : public Touchscreen, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
+  void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
+
+ protected:
+  void hard_reset_();
+  uint8_t read_byte_(uint8_t addr);
+  void update_touches() override;
+
+  InternalGPIOPin *interrupt_pin_{nullptr};
+  GPIOPin *reset_pin_{nullptr};
+
+  uint8_t read_touch_count_();
+  uint16_t read_touch_coordinate_(uint8_t coordinate);
+  uint8_t read_touch_id_(uint8_t id_address);
+};
+
+}  // namespace ft63x6
+}  // namespace esphome

esphome/components/ft63x6/touchscreen.py

@@ -0,0 +1,44 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+
+from esphome import pins
+from esphome.components import i2c, touchscreen
+from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
+
+CODEOWNERS = ["@gpambrozio"]
+DEPENDENCIES = ["i2c"]
+
+ft6336u_ns = cg.esphome_ns.namespace("ft63x6")
+FT63X6Touchscreen = ft6336u_ns.class_(
+    "FT63X6Touchscreen",
+    touchscreen.Touchscreen,
+    i2c.I2CDevice,
+)
+
+CONF_FT63X6_ID = "ft63x6_id"
+
+
+CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(FT63X6Touchscreen),
+            cv.Optional(CONF_INTERRUPT_PIN): cv.All(
+                pins.internal_gpio_input_pin_schema
+            ),
+            cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+        }
+    ).extend(i2c.i2c_device_schema(0x38))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await touchscreen.register_touchscreen(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if interrupt_pin_config := config.get(CONF_INTERRUPT_PIN):
+        interrupt_pin = await cg.gpio_pin_expression(interrupt_pin_config)
+        cg.add(var.set_interrupt_pin(interrupt_pin))
+    if reset_pin_config := config.get(CONF_RESET_PIN):
+        reset_pin = await cg.gpio_pin_expression(reset_pin_config)
+        cg.add(var.set_reset_pin(reset_pin))

esphome/components/graphical_display_menu/__init__.py

@@ -0,0 +1,96 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import display, font, color
+from esphome.const import CONF_ID, CONF_TRIGGER_ID
+from esphome import automation, core
+
+from esphome.components.display_menu_base import (
+    DISPLAY_MENU_BASE_SCHEMA,
+    DisplayMenuComponent,
+    display_menu_to_code,
+)
+
+CONF_DISPLAY = "display"
+CONF_FONT = "font"
+CONF_MENU_ITEM_VALUE = "menu_item_value"
+CONF_FOREGROUND_COLOR = "foreground_color"
+CONF_BACKGROUND_COLOR = "background_color"
+CONF_ON_REDRAW = "on_redraw"
+
+graphical_display_menu_ns = cg.esphome_ns.namespace("graphical_display_menu")
+GraphicalDisplayMenu = graphical_display_menu_ns.class_(
+    "GraphicalDisplayMenu", DisplayMenuComponent
+)
+GraphicalDisplayMenuConstPtr = GraphicalDisplayMenu.operator("ptr").operator("const")
+MenuItemValueArguments = graphical_display_menu_ns.struct("MenuItemValueArguments")
+MenuItemValueArgumentsConstPtr = MenuItemValueArguments.operator("ptr").operator(
+    "const"
+)
+GraphicalDisplayMenuOnRedrawTrigger = graphical_display_menu_ns.class_(
+    "GraphicalDisplayMenuOnRedrawTrigger", automation.Trigger
+)
+
+CODEOWNERS = ["@MrMDavidson"]
+
+AUTO_LOAD = ["display_menu_base"]
+
+CONFIG_SCHEMA = DISPLAY_MENU_BASE_SCHEMA.extend(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(GraphicalDisplayMenu),
+            cv.Optional(CONF_DISPLAY): cv.use_id(display.DisplayBuffer),
+            cv.Required(CONF_FONT): cv.use_id(font.Font),
+            cv.Optional(CONF_MENU_ITEM_VALUE): cv.templatable(cv.string),
+            cv.Optional(CONF_FOREGROUND_COLOR): cv.use_id(color.ColorStruct),
+            cv.Optional(CONF_BACKGROUND_COLOR): cv.use_id(color.ColorStruct),
+            cv.Optional(CONF_ON_REDRAW): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        GraphicalDisplayMenuOnRedrawTrigger
+                    )
+                }
+            ),
+        }
+    )
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    if display_config := config.get(CONF_DISPLAY):
+        drawing_display = await cg.get_variable(display_config)
+        cg.add(var.set_display(drawing_display))
+
+    menu_font = await cg.get_variable(config[CONF_FONT])
+    cg.add(var.set_font(menu_font))
+
+    if (menu_item_value_config := config.get(CONF_MENU_ITEM_VALUE, None)) is not None:
+        if isinstance(menu_item_value_config, core.Lambda):
+            template_ = await cg.templatable(
+                menu_item_value_config,
+                [(MenuItemValueArgumentsConstPtr, "it")],
+                cg.std_string,
+            )
+            cg.add(var.set_menu_item_value(template_))
+        else:
+            cg.add(var.set_menu_item_value(menu_item_value_config))
+
+    if foreground_color_config := config.get(CONF_FOREGROUND_COLOR):
+        foreground_color = await cg.get_variable(foreground_color_config)
+        cg.add(var.set_foreground_color(foreground_color))
+
+    if background_color_config := config.get(CONF_BACKGROUND_COLOR):
+        background_color = await cg.get_variable(background_color_config)
+        cg.add(var.set_background_color(background_color))
+
+    for conf in config.get(CONF_ON_REDRAW, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(GraphicalDisplayMenuConstPtr, "it")], conf
+        )
+
+    await display_menu_to_code(var, config)
+
+    cg.add_define("USE_GRAPHICAL_DISPLAY_MENU")

esphome/components/graphical_display_menu/graphical_display_menu.cpp

@@ -0,0 +1,243 @@
+#include "graphical_display_menu.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+#include <cstdlib>
+#include "esphome/components/display/display.h"
+
+namespace esphome {
+namespace graphical_display_menu {
+
+static const char *const TAG = "graphical_display_menu";
+
+void GraphicalDisplayMenu::setup() {
+  if (this->display_ != nullptr) {
+    display::display_writer_t writer = [this](display::Display &it) { this->draw_menu(); };
+    this->display_page_ = make_unique<display::DisplayPage>(writer);
+  }
+
+  if (!this->menu_item_value_.has_value()) {
+    this->menu_item_value_ = [](const MenuItemValueArguments *it) {
+      std::string label = " ";
+      if (it->is_item_selected && it->is_menu_editing) {
+        label.append(">");
+        label.append(it->item->get_value_text());
+        label.append("<");
+      } else {
+        label.append("(");
+        label.append(it->item->get_value_text());
+        label.append(")");
+      }
+      return label;
+    };
+  }
+
+  display_menu_base::DisplayMenuComponent::setup();
+}
+
+void GraphicalDisplayMenu::dump_config() {
+  ESP_LOGCONFIG(TAG, "Graphical Display Menu");
+  ESP_LOGCONFIG(TAG, "Has Display: %s", YESNO(this->display_ != nullptr));
+  ESP_LOGCONFIG(TAG, "Popup Mode: %s", YESNO(this->display_ != nullptr));
+  ESP_LOGCONFIG(TAG, "Advanced Drawing Mode: %s", YESNO(this->display_ == nullptr));
+  ESP_LOGCONFIG(TAG, "Has Font: %s", YESNO(this->font_ != nullptr));
+  ESP_LOGCONFIG(TAG, "Mode: %s", this->mode_ == display_menu_base::MENU_MODE_ROTARY ? "Rotary" : "Joystick");
+  ESP_LOGCONFIG(TAG, "Active: %s", YESNO(this->active_));
+  ESP_LOGCONFIG(TAG, "Menu items:");
+  for (size_t i = 0; i < this->displayed_item_->items_size(); i++) {
+    auto *item = this->displayed_item_->get_item(i);
+    ESP_LOGCONFIG(TAG, "  %i: %s (Type: %s, Immediate Edit: %s)", i, item->get_text().c_str(),
+                  LOG_STR_ARG(display_menu_base::menu_item_type_to_string(item->get_type())),
+                  YESNO(item->get_immediate_edit()));
+  }
+}
+
+void GraphicalDisplayMenu::set_display(display::Display *display) { this->display_ = display; }
+
+void GraphicalDisplayMenu::set_font(display::BaseFont *font) { this->font_ = font; }
+
+void GraphicalDisplayMenu::set_foreground_color(Color foreground_color) { this->foreground_color_ = foreground_color; }
+void GraphicalDisplayMenu::set_background_color(Color background_color) { this->background_color_ = background_color; }
+
+void GraphicalDisplayMenu::on_before_show() {
+  if (this->display_ != nullptr) {
+    this->previous_display_page_ = this->display_->get_active_page();
+    this->display_->show_page(this->display_page_.get());
+    this->display_->clear();
+  } else {
+    this->update();
+  }
+}
+
+void GraphicalDisplayMenu::on_before_hide() {
+  if (this->previous_display_page_ != nullptr) {
+    this->display_->show_page((display::DisplayPage *) this->previous_display_page_);
+    this->display_->clear();
+    this->update();
+    this->previous_display_page_ = nullptr;
+  } else {
+    this->update();
+  }
+}
+
+void GraphicalDisplayMenu::draw_and_update() {
+  this->update();
+
+  // If we're in advanced drawing mode we won't have a display and will instead require the update callback to do
+  // our drawing
+  if (this->display_ != nullptr) {
+    draw_menu();
+  }
+}
+
+void GraphicalDisplayMenu::draw_menu() {
+  if (this->display_ == nullptr) {
+    ESP_LOGE(TAG, "draw_menu() called without a display_. This is only available when using the menu in pop up mode");
+    return;
+  }
+  display::Rect bounds(0, 0, this->display_->get_width(), this->display_->get_height());
+  this->draw_menu_internal_(this->display_, &bounds);
+}
+
+void GraphicalDisplayMenu::draw(display::Display *display, const display::Rect *bounds) {
+  this->draw_menu_internal_(display, bounds);
+}
+
+void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const display::Rect *bounds) {
+  int total_height = 0;
+  int y_padding = 2;
+  bool scroll_menu_items = false;
+  std::vector<display::Rect> menu_dimensions;
+  int number_items_fit_to_screen = 0;
+  const int max_item_index = this->displayed_item_->items_size() - 1;
+
+  for (size_t i = 0; i <= max_item_index; i++) {
+    const auto *item = this->displayed_item_->get_item(i);
+    const bool selected = i == this->cursor_index_;
+    const display::Rect item_dimensions = this->measure_item(display, item, bounds, selected);
+
+    menu_dimensions.push_back(item_dimensions);
+    total_height += item_dimensions.h + (i == 0 ? 0 : y_padding);
+
+    if (total_height <= bounds->h) {
+      number_items_fit_to_screen++;
+    } else {
+      // Scroll the display if the selected item or the item immediately after it overflows
+      if ((selected) || (i == this->cursor_index_ + 1)) {
+        scroll_menu_items = true;
+      }
+    }
+  }
+
+  // Determine what items to draw
+  int first_item_index = 0;
+  int last_item_index = max_item_index;
+
+  if (number_items_fit_to_screen <= 1) {
+    // If only one item can fit to the bounds draw the current cursor item
+    last_item_index = std::min(last_item_index, this->cursor_index_ + 1);
+    first_item_index = this->cursor_index_;
+  } else {
+    if (scroll_menu_items) {
+      // Attempt to draw the item after the current item (+1 for equality check in the draw loop)
+      last_item_index = std::min(last_item_index, this->cursor_index_ + 1);
+
+      // Go back through the measurements to determine how many prior items we can fit
+      int height_left_to_use = bounds->h;
+      for (int i = last_item_index; i >= 0; i--) {
+        const display::Rect item_dimensions = menu_dimensions[i];
+        height_left_to_use -= (item_dimensions.h + y_padding);
+
+        if (height_left_to_use <= 0) {
+          // Ran out of space -  this is our first item to draw
+          first_item_index = i;
+          break;
+        }
+      }
+      const int items_to_draw = last_item_index - first_item_index;
+      // Dont't draw last item partially if it is the selected item
+      if ((this->cursor_index_ == last_item_index) && (number_items_fit_to_screen <= items_to_draw) &&
+          (first_item_index < max_item_index)) {
+        first_item_index++;
+      }
+    }
+  }
+
+  // Render the items into the view port
+  display->start_clipping(*bounds);
+
+  int y_offset = bounds->y;
+  for (size_t i = first_item_index; i <= last_item_index; i++) {
+    const auto *item = this->displayed_item_->get_item(i);
+    const bool selected = i == this->cursor_index_;
+    display::Rect dimensions = menu_dimensions[i];
+
+    dimensions.y = y_offset;
+    dimensions.x = bounds->x;
+    this->draw_item(display, item, &dimensions, selected);
+
+    y_offset = dimensions.y + dimensions.h + y_padding;
+  }
+
+  display->end_clipping();
+}
+
+display::Rect GraphicalDisplayMenu::measure_item(display::Display *display, const display_menu_base::MenuItem *item,
+                                                 const display::Rect *bounds, const bool selected) {
+  display::Rect dimensions(0, 0, 0, 0);
+
+  if (selected) {
+    // TODO: Support selection glyph
+    dimensions.w += 0;
+    dimensions.h += 0;
+  }
+
+  std::string label = item->get_text();
+  if (item->has_value()) {
+    // Append to label
+    MenuItemValueArguments args(item, selected, this->editing_);
+    label.append(this->menu_item_value_.value(&args));
+  }
+
+  int x1;
+  int y1;
+  int width;
+  int height;
+  display->get_text_bounds(0, 0, label.c_str(), this->font_, display::TextAlign::TOP_LEFT, &x1, &y1, &width, &height);
+
+  dimensions.w = std::min((int16_t) width, bounds->w);
+  dimensions.h = std::min((int16_t) height, bounds->h);
+
+  return dimensions;
+}
+
+inline void GraphicalDisplayMenu::draw_item(display::Display *display, const display_menu_base::MenuItem *item,
+                                            const display::Rect *bounds, const bool selected) {
+  const auto background_color = selected ? this->foreground_color_ : this->background_color_;
+  const auto foreground_color = selected ? this->background_color_ : this->foreground_color_;
+
+  // int background_width = std::max(bounds->width, available_width);
+  int background_width = bounds->w;
+
+  if (selected) {
+    display->filled_rectangle(bounds->x, bounds->y, background_width, bounds->h, background_color);
+  }
+
+  std::string label = item->get_text();
+  if (item->has_value()) {
+    MenuItemValueArguments args(item, selected, this->editing_);
+    label.append(this->menu_item_value_.value(&args));
+  }
+
+  display->print(bounds->x, bounds->y, this->font_, foreground_color, display::TextAlign::TOP_LEFT, label.c_str());
+}
+
+void GraphicalDisplayMenu::draw_item(const display_menu_base::MenuItem *item, const uint8_t row, const bool selected) {
+  ESP_LOGE(TAG, "draw_item(MenuItem *item, uint8_t row, bool selected) called. The graphical_display_menu specific "
+                "draw_item should be called.");
+}
+
+void GraphicalDisplayMenu::update() { this->on_redraw_callbacks_.call(); }
+
+}  // namespace graphical_display_menu
+}  // namespace esphome

esphome/components/graphical_display_menu/graphical_display_menu.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "esphome/core/color.h"
+#include "esphome/components/display_menu_base/display_menu_base.h"
+#include "esphome/components/display_menu_base/menu_item.h"
+#include "esphome/core/automation.h"
+#include <cstdlib>
+
+namespace esphome {
+
+// forward declare from display namespace
+namespace display {
+class Display;
+class DisplayPage;
+class BaseFont;
+class Rect;
+}  // namespace display
+
+namespace graphical_display_menu {
+
+const Color COLOR_ON(255, 255, 255, 255);
+const Color COLOR_OFF(0, 0, 0, 0);
+
+struct MenuItemValueArguments {
+  MenuItemValueArguments(const display_menu_base::MenuItem *item, bool is_item_selected, bool is_menu_editing) {
+    this->item = item;
+    this->is_item_selected = is_item_selected;
+    this->is_menu_editing = is_menu_editing;
+  }
+
+  const display_menu_base::MenuItem *item;
+  bool is_item_selected;
+  bool is_menu_editing;
+};
+
+class GraphicalDisplayMenu : public display_menu_base::DisplayMenuComponent {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+  void set_display(display::Display *display);
+  void set_font(display::BaseFont *font);
+  template<typename V> void set_menu_item_value(V menu_item_value) { this->menu_item_value_ = menu_item_value; }
+  void set_foreground_color(Color foreground_color);
+  void set_background_color(Color background_color);
+
+  void add_on_redraw_callback(std::function<void()> &&cb) { this->on_redraw_callbacks_.add(std::move(cb)); }
+
+  void draw(display::Display *display, const display::Rect *bounds);
+
+ protected:
+  void draw_and_update() override;
+  void draw_menu() override;
+  void draw_menu_internal_(display::Display *display, const display::Rect *bounds);
+  void draw_item(const display_menu_base::MenuItem *item, uint8_t row, bool selected) override;
+  virtual display::Rect measure_item(display::Display *display, const display_menu_base::MenuItem *item,
+                                     const display::Rect *bounds, bool selected);
+  virtual void draw_item(display::Display *display, const display_menu_base::MenuItem *item,
+                         const display::Rect *bounds, bool selected);
+  void update() override;
+
+  void on_before_show() override;
+  void on_before_hide() override;
+
+  std::unique_ptr<display::DisplayPage> display_page_{nullptr};
+  const display::DisplayPage *previous_display_page_{nullptr};
+  display::Display *display_{nullptr};
+  display::BaseFont *font_{nullptr};
+  TemplatableValue<std::string, const MenuItemValueArguments *> menu_item_value_;
+  Color foreground_color_{COLOR_ON};
+  Color background_color_{COLOR_OFF};
+
+  CallbackManager<void()> on_redraw_callbacks_{};
+};
+
+class GraphicalDisplayMenuOnRedrawTrigger : public Trigger<const GraphicalDisplayMenu *> {
+ public:
+  explicit GraphicalDisplayMenuOnRedrawTrigger(GraphicalDisplayMenu *parent) {
+    parent->add_on_redraw_callback([this, parent]() { this->trigger(parent); });
+  }
+};
+
+}  // namespace graphical_display_menu
+}  // namespace esphome

esphome/components/gt911/__init__.py

@@ -0,0 +1,6 @@
+import esphome.codegen as cg
+
+CODEOWNERS = ["@jesserockz", "@clydebarrow"]
+DEPENDENCIES = ["i2c"]
+
+gt911_ns = cg.esphome_ns.namespace("gt911")

esphome/components/gt911/binary_sensor/__init__.py

@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import binary_sensor
+from esphome.const import CONF_INDEX
+
+from .. import gt911_ns
+from ..touchscreen import GT911Touchscreen, GT911ButtonListener
+
+CONF_GT911_ID = "gt911_id"
+
+GT911Button = gt911_ns.class_(
+    "GT911Button",
+    binary_sensor.BinarySensor,
+    cg.Component,
+    GT911ButtonListener,
+    cg.Parented.template(GT911Touchscreen),
+)
+
+CONFIG_SCHEMA = binary_sensor.binary_sensor_schema(GT911Button).extend(
+    {
+        cv.GenerateID(CONF_GT911_ID): cv.use_id(GT911Touchscreen),
+        cv.Optional(CONF_INDEX, default=0): cv.int_range(min=0, max=3),
+    }
+)
+
+
+async def to_code(config):
+    var = await binary_sensor.new_binary_sensor(config)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_GT911_ID])
+    cg.add(var.set_index(config[CONF_INDEX]))

esphome/components/gt911/binary_sensor/gt911_button.cpp

@@ -0,0 +1,27 @@
+#include "gt911_button.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace gt911 {
+
+static const char *const TAG = "GT911.binary_sensor";
+
+void GT911Button::setup() {
+  this->parent_->register_button_listener(this);
+  this->publish_initial_state(false);
+}
+
+void GT911Button::dump_config() {
+  LOG_BINARY_SENSOR("", "GT911 Button", this);
+  ESP_LOGCONFIG(TAG, "  Index: %u", this->index_);
+}
+
+void GT911Button::update_button(uint8_t index, bool state) {
+  if (index != this->index_)
+    return;
+
+  this->publish_state(state);
+}
+
+}  // namespace gt911
+}  // namespace esphome

esphome/components/gt911/binary_sensor/gt911_button.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/components/gt911/touchscreen/gt911_touchscreen.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace gt911 {
+
+class GT911Button : public binary_sensor::BinarySensor,
+                    public Component,
+                    public GT911ButtonListener,
+                    public Parented<GT911Touchscreen> {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+  void set_index(uint8_t index) { this->index_ = index; }
+
+  void update_button(uint8_t index, bool state) override;
+
+ protected:
+  uint8_t index_;
+};
+
+}  // namespace gt911
+}  // namespace esphome