Fix missing s

2022.12.6

.devcontainer/devcontainer.json

@@ -1,6 +1,6 @@
 {
   "name": "ESPHome Dev",
-  "image": "esphome/esphome-lint:dev",
+  "image": "ghcr.io/esphome/esphome-lint:dev",
   "postCreateCommand": [
     "script/devcontainer-post-create"
   ],

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,6 +1,6 @@
 # What does this implement/fix?
 
-Quick description and explanation of changes
+<!-- Quick description and explanation of changes -->
 
 ## Types of changes
 
@@ -18,6 +18,7 @@ Quick description and explanation of changes
 - [ ] ESP32
 - [ ] ESP32 IDF
 - [ ] ESP8266
+- [ ] RP2040
 
 ## Example entry for `config.yaml`:
 <!--

.github/workflows/ci-docker.yml

@@ -28,6 +28,7 @@ jobs:
     name: Build docker containers
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         arch: [amd64, armv7, aarch64]
         build_type: ["ha-addon", "docker", "lint"]

.github/workflows/ci.yml

@@ -48,6 +48,10 @@ jobs:
             file: tests/test5.yaml
             name: Test tests/test5.yaml
             pio_cache_key: test5
+          - id: test
+            file: tests/test6.yaml
+            name: Test tests/test6.yaml
+            pio_cache_key: test6
           - id: pytest
             name: Run pytest
           - id: clang-format
@@ -85,7 +89,7 @@ jobs:
         uses: actions/setup-python@v4
         id: python
         with:
-          python-version: "3.8"
+          python-version: "3.9"
 
       - name: Cache virtualenv
         uses: actions/cache@v3
@@ -173,7 +177,7 @@ jobs:
 
       - name: Run yamllint
         if: matrix.id == 'yamllint'
-        uses: frenck/action-yamllint@v1.3.0
+        uses: frenck/action-yamllint@v1.3.1
 
       - name: Suggested changes
         run: script/ci-suggest-changes

.github/workflows/lock.yml

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

.github/workflows/release.yml

@@ -30,8 +30,12 @@ jobs:
             TAG=$(cat esphome/const.py | sed -n -E "s/^__version__\s+=\s+\"(.+)\"$/\1/p")
             today="$(date --utc '+%Y%m%d')"
             TAG="${TAG}${today}"
+            BRANCH=${GITHUB_REF#refs/heads/}
+            if [[ "$BRANCH" != "dev" ]]; then
+              TAG="${TAG}-${BRANCH}"
+            fi
           fi
-          echo "::set-output name=tag::${TAG}"
+          echo "tag=${TAG}" >> $GITHUB_OUTPUT
         # yamllint enable rule:line-length
 
   deploy-pypi:
@@ -57,7 +61,7 @@ jobs:
         run: twine upload dist/*
 
   deploy-docker:
-    name: Build and publish docker containers
+    name: Build and publish ESPHome ${{ matrix.image.title}}
     if: github.repository == 'esphome/esphome'
     permissions:
       contents: read
@@ -66,8 +70,19 @@ jobs:
     needs: [init]
     strategy:
       matrix:
-        arch: [amd64, armv7, aarch64]
-        build_type: ["ha-addon", "docker", "lint"]
+        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"
     steps:
       - uses: actions/checkout@v3
       - name: Set up Python
@@ -92,54 +107,29 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Generate short tags
+        id: tags
+        run: |
+          docker/generate_tags.py \
+            --tag "${{ needs.init.outputs.tag }}" \
+            --suffix "${{ matrix.image.suffix }}"
+
       - name: Build and push
-        run: |
-          docker/build.py \
-            --tag "${{ needs.init.outputs.tag }}" \
-            --arch "${{ matrix.arch }}" \
-            --build-type "${{ matrix.build_type }}" \
-            build \
-            --push
-
-  deploy-docker-manifest:
-    if: github.repository == 'esphome/esphome'
-    permissions:
-      contents: read
-      packages: write
-    runs-on: ubuntu-latest
-    needs: [init, deploy-docker]
-    strategy:
-      matrix:
-        build_type: ["ha-addon", "docker", "lint"]
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: docker/build-push-action@v3
         with:
-          python-version: "3.9"
-      - name: Enable experimental manifest support
-        run: |
-          mkdir -p ~/.docker
-          echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
-
-      - name: Log in to docker hub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-      - name: Log in to the GitHub container registry
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Run manifest
-        run: |
-          docker/build.py \
-            --tag "${{ needs.init.outputs.tag }}" \
-            --build-type "${{ matrix.build_type }}" \
-            manifest
+          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 }}
 
   deploy-ha-addon-repo:
     if: github.repository == 'esphome/esphome' && github.event_name == 'release'

.github/workflows/stale.yml

@@ -18,7 +18,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v6
         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@v5
+      - uses: actions/stale@v6
         with:
           days-before-pr-stale: -1
           days-before-pr-close: -1

.gitpod.yml

@@ -1,8 +0,0 @@
----
-ports:
-  - port: 6052
-    onOpen: open-preview
-tasks:
-  # yamllint disable-line rule:line-length
-  - before: pyenv local $(pyenv version | grep '^3\.' | cut -d ' ' -f 1) && script/setup
-    command: python -m esphome dashboard config

.pre-commit-config.yaml

@@ -3,15 +3,15 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/ambv/black
-    rev: 22.6.0
+    rev: 22.10.0
     hooks:
       - id: black
         args:
           - --safe
           - --quiet
         files: ^((esphome|script|tests)/.+)?[^/]+\.py$
-  - repo: https://gitlab.com/pycqa/flake8
-    rev: 4.0.1
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.0.0
     hooks:
       - id: flake8
         additional_dependencies:
@@ -27,7 +27,7 @@ repos:
           - --branch=release
           - --branch=beta
   - repo: https://github.com/asottile/pyupgrade
-    rev: v2.37.3
+    rev: v3.3.0
     hooks:
       - id: pyupgrade
-        args: [--py38-plus]
+        args: [--py39-plus]

CODEOWNERS

@@ -13,6 +13,7 @@ esphome/core/* @esphome/core
 # Integrations
 esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
+esphome/components/adc128s102/* @DeerMaximum
 esphome/components/addressable_light/* @justfalter
 esphome/components/airthings_ble/* @jeromelaban
 esphome/components/airthings_wave_mini/* @ncareau
@@ -57,12 +58,14 @@ esphome/components/cse7761/* @berfenger
 esphome/components/ct_clamp/* @jesserockz
 esphome/components/current_based/* @djwmarcx
 esphome/components/dac7678/* @NickB1
+esphome/components/daikin_brc/* @hagak
 esphome/components/daly_bms/* @s1lvi0
 esphome/components/dashboard_import/* @esphome/core
 esphome/components/debug/* @OttoWinter
 esphome/components/delonghi/* @grob6000
 esphome/components/dfplayer/* @glmnet
 esphome/components/dht/* @OttoWinter
+esphome/components/display_menu_base/* @numo68
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/dsmr/* @glmnet @zuidwijk
@@ -70,13 +73,16 @@ esphome/components/ektf2232/* @jesserockz
 esphome/components/ens210/* @itn3rd77
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @jesserockz
+esphome/components/esp32_ble_client/* @jesserockz
 esphome/components/esp32_ble_server/* @jesserockz
 esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp8266/* @esphome/core
+esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/exposure_notifications/* @OttoWinter
 esphome/components/ezo/* @ssieb
+esphome/components/ezo_pmp/* @carlos-sarmiento
 esphome/components/factory_reset/* @anatoly-savchenkov
 esphome/components/fastled_base/* @OttoWinter
 esphome/components/feedback/* @ianchi
@@ -105,6 +111,7 @@ esphome/components/integration/* @OttoWinter
 esphome/components/interval/* @esphome/core
 esphome/components/json/* @OttoWinter
 esphome/components/kalman_combinator/* @Cat-Ion
+esphome/components/lcd_menu/* @numo68
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
 esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
@@ -179,6 +186,8 @@ esphome/components/rc522_spi/* @glmnet
 esphome/components/restart/* @esphome/core
 esphome/components/rf_bridge/* @jesserockz
 esphome/components/rgbct/* @jesserockz
+esphome/components/rp2040/* @jesserockz
+esphome/components/rp2040_pwm/* @jesserockz
 esphome/components/rtttl/* @glmnet
 esphome/components/safe_mode/* @jsuanet @paulmonigatti
 esphome/components/scd4x/* @martgras @sjtrny
@@ -199,6 +208,7 @@ esphome/components/sim800l/* @glmnet
 esphome/components/sm2135/* @BoukeHaarsma23
 esphome/components/sml/* @alengwenus
 esphome/components/smt100/* @piechade
+esphome/components/sn74hc165/* @jesserockz
 esphome/components/socket/* @esphome/core
 esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/spi/* @esphome/core
@@ -253,8 +263,9 @@ esphome/components/wake_on_lan/* @willwill2will54
 esphome/components/web_server_base/* @OttoWinter
 esphome/components/whirlpool/* @glmnet
 esphome/components/whynter/* @aeonsablaze
+esphome/components/wl_134/* @hobbypunk90
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl
 esphome/components/xiaomi_mhoc303/* @drug123
 esphome/components/xiaomi_mhoc401/* @vevsvevs
 esphome/components/xiaomi_rtcgq02lm/* @jesserockz
-esphome/components/xpt2046/* @numo68
+esphome/components/xpt2046/* @nielsnl68 @numo68

docker/Dockerfile

@@ -6,17 +6,14 @@
 ARG BASEIMGTYPE=docker
 
 # https://github.com/hassio-addons/addon-debian-base/releases
-FROM ghcr.io/hassio-addons/debian-base/amd64:5.3.0 AS base-hassio-amd64
-FROM ghcr.io/hassio-addons/debian-base/aarch64:5.3.0 AS base-hassio-arm64
-FROM ghcr.io/hassio-addons/debian-base/armv7:5.3.0 AS base-hassio-armv7
+FROM ghcr.io/hassio-addons/debian-base:6.1.3 AS base-hassio
 # https://hub.docker.com/_/debian?tab=tags&page=1&name=bullseye
-FROM debian:bullseye-20220328-slim AS base-docker-amd64
-FROM debian:bullseye-20220328-slim AS base-docker-arm64
-FROM debian:bullseye-20220328-slim AS base-docker-armv7
+FROM debian:bullseye-20221024-slim AS base-docker
 
-# Use TARGETARCH/TARGETVARIANT defined by docker
-# https://docs.docker.com/engine/reference/builder/#automatic-platform-args-in-the-global-scope
-FROM base-${BASEIMGTYPE}-${TARGETARCH}${TARGETVARIANT} AS base
+FROM base-${BASEIMGTYPE} AS base
+
+ARG TARGETARCH
+ARG TARGETVARIANT
 
 RUN \
     apt-get update \
@@ -29,8 +26,8 @@ RUN \
         python3-cryptography=3.3.2-1 \
         iputils-ping=3:20210202-1 \
         git=1:2.30.2-1 \
-        curl=7.74.0-1.3+deb11u1 \
-        openssh-client=1:8.4p1-5 \
+        curl=7.74.0-1.3+deb11u3 \
+        openssh-client=1:8.4p1-5+deb11u1 \
     && rm -rf \
         /tmp/* \
         /var/{cache,log}/* \
@@ -42,11 +39,19 @@ ENV \
   # Store globally installed pio libs in /piolibs
   PLATFORMIO_GLOBALLIB_DIR=/piolibs
 
+# Support legacy binaries on Debian multiarch system. There is no "correct" way
+# to do this, other than using properly built toolchains...
+# 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; \
+    fi
+
 RUN \
     # Ubuntu python3-pip is missing wheel
     pip3 install --no-cache-dir \
         wheel==0.37.1 \
-        platformio==6.0.2 \
+        platformio==6.1.5 \
     # Change some platformio settings
     && platformio settings set enable_telemetry No \
     && platformio settings set check_platformio_interval 1000000 \
@@ -94,7 +99,7 @@ RUN \
     apt-get update \
     # Use pinned versions so that we get updates with build caching
     && apt-get install -y --no-install-recommends \
-        nginx-light=1.18.0-6.1+deb11u2 \
+        nginx-light=1.18.0-6.1+deb11u3 \
     && rm -rf \
         /tmp/* \
         /var/{cache,log}/* \
@@ -134,7 +139,7 @@ RUN \
         clang-tidy-11=1:11.0.1-2 \
         patch=2.7.6-7 \
         software-properties-common=0.96.20.2-2.1 \
-        nano=5.4-2+deb11u1 \
+        nano=5.4-2+deb11u2 \
         build-essential=12.9 \
         python3-dev=3.9.2-3 \
     && rm -rf \

docker/generate_tags.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import re
+import os
+import argparse
+import json
+
+CHANNEL_DEV = "dev"
+CHANNEL_BETA = "beta"
+CHANNEL_RELEASE = "release"
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--tag",
+    type=str,
+    required=True,
+    help="The main docker tag to push to. If a version number also adds latest and/or beta tag",
+)
+parser.add_argument(
+    "--suffix",
+    type=str,
+    required=True,
+    help="The suffix of the tag.",
+)
+
+
+def main():
+    args = parser.parse_args()
+
+    # detect channel from tag
+    match = re.match(r"^(\d+\.\d+)(?:\.\d+)?(b\d+)?$", args.tag)
+    major_minor_version = None
+    if match is None:
+        channel = CHANNEL_DEV
+    elif match.group(2) is None:
+        major_minor_version = match.group(1)
+        channel = CHANNEL_RELEASE
+    else:
+        channel = CHANNEL_BETA
+
+    tags_to_push = [args.tag]
+    if channel == CHANNEL_DEV:
+        tags_to_push.append("dev")
+    elif channel == CHANNEL_BETA:
+        tags_to_push.append("beta")
+    elif channel == CHANNEL_RELEASE:
+        # Additionally push to beta
+        tags_to_push.append("beta")
+        tags_to_push.append("latest")
+
+        if major_minor_version:
+            tags_to_push.append("stable")
+            tags_to_push.append(major_minor_version)
+
+    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 = []
+
+        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)
+
+
+if __name__ == "__main__":
+    main()

docker/ha-addon-rootfs/etc/services.d/esphome/finish

@@ -3,7 +3,13 @@
 # Community Hass.io Add-ons: ESPHome
 # Take down the S6 supervision tree when ESPHome fails
 # ==============================================================================
-if -n { s6-test $# -ne 0 }
-if -n { s6-test ${1} -eq 256 }
 
-s6-svscanctl -t /var/run/s6/services
+declare APP_EXIT_CODE=${1}
+
+if [[ "${APP_EXIT_CODE}" -ne 0 ]] && [[ "${APP_EXIT_CODE}" -ne 256 ]]; then
+  bashio::log.warning "Halt add-on with exit code ${APP_EXIT_CODE}"
+  echo "${APP_EXIT_CODE}" > /run/s6-linux-init-container-results/exitcode
+  exec /run/s6/basedir/bin/halt
+fi
+
+bashio::log.info "Service restart after closing"

docker/ha-addon-rootfs/etc/services.d/esphome/run

@@ -22,6 +22,14 @@ if bashio::config.has_value 'relative_url'; then
     export ESPHOME_DASHBOARD_RELATIVE_URL=$(bashio::config 'relative_url')
 fi
 
+if bashio::config.has_value 'default_compile_process_limit'; then
+    export ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT=$(bashio::config 'default_compile_process_limit')
+else
+    if grep -q 'Raspberry Pi 3' /proc/cpuinfo; then
+        export ESPHOME_DEFAULT_COMPILE_PROCESS_LIMIT=1;
+    fi
+fi
+
 pio_cache_base=/data/cache/platformio
 # we can't set core_dir, because the settings file is stored in `core_dir/appstate.json`
 # setting `core_dir` would therefore prevent pio from accessing

docker/ha-addon-rootfs/etc/services.d/nginx/finish

@@ -3,7 +3,13 @@
 # Community Hass.io Add-ons: ESPHome
 # Take down the S6 supervision tree when NGINX fails
 # ==============================================================================
-if -n { s6-test $# -ne 0 }
-if -n { s6-test ${1} -eq 256 }
 
-s6-svscanctl -t /var/run/s6/services
+declare APP_EXIT_CODE=${1}
+
+if [[ "${APP_EXIT_CODE}" -ne 0 ]] && [[ "${APP_EXIT_CODE}" -ne 256 ]]; then
+  bashio::log.warning "Halt add-on with exit code ${APP_EXIT_CODE}"
+  echo "${APP_EXIT_CODE}" > /run/s6-linux-init-container-results/exitcode
+  exec /run/s6/basedir/bin/halt
+fi
+
+bashio::log.info "Service restart after closing"

esphome/__main__.py

@@ -4,6 +4,7 @@ import logging
 import os
 import re
 import sys
+import time
 from datetime import datetime
 
 from esphome import const, writer, yaml_util
@@ -22,6 +23,9 @@ from esphome.const import (
     CONF_ESPHOME,
     CONF_PLATFORMIO_OPTIONS,
     CONF_SUBSTITUTIONS,
+    PLATFORM_ESP32,
+    PLATFORM_ESP8266,
+    PLATFORM_RP2040,
     SECRETS_FILES,
 )
 from esphome.core import CORE, EsphomeError, coroutine
@@ -101,11 +105,11 @@ def run_miniterm(config, port):
 
     if CONF_LOGGER not in config:
         _LOGGER.info("Logger is not enabled. Not starting UART logs.")
-        return
+        return 1
     baud_rate = config["logger"][CONF_BAUD_RATE]
     if baud_rate == 0:
         _LOGGER.info("UART logging is disabled (baud_rate=0). Not starting UART logs.")
-        return
+        return 1
     _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
 
     backtrace_state = False
@@ -119,25 +123,34 @@ def run_miniterm(config, port):
         ser.dtr = False
         ser.rts = False
 
-    with ser:
-        while True:
-            try:
-                raw = ser.readline()
-            except serial.SerialException:
-                _LOGGER.error("Serial port closed!")
-                return
-            line = (
-                raw.replace(b"\r", b"")
-                .replace(b"\n", b"")
-                .decode("utf8", "backslashreplace")
-            )
-            time = datetime.now().time().strftime("[%H:%M:%S]")
-            message = time + line
-            safe_print(message)
+    tries = 0
+    while tries < 5:
+        try:
+            with ser:
+                while True:
+                    try:
+                        raw = ser.readline()
+                    except serial.SerialException:
+                        _LOGGER.error("Serial port closed!")
+                        return 0
+                    line = (
+                        raw.replace(b"\r", b"")
+                        .replace(b"\n", b"")
+                        .decode("utf8", "backslashreplace")
+                    )
+                    time_str = datetime.now().time().strftime("[%H:%M:%S]")
+                    message = time_str + line
+                    safe_print(message)
 
-            backtrace_state = platformio_api.process_stacktrace(
-                config, line, backtrace_state=backtrace_state
-            )
+                    backtrace_state = platformio_api.process_stacktrace(
+                        config, line, backtrace_state=backtrace_state
+                    )
+        except serial.SerialException:
+            tries += 1
+            time.sleep(1)
+    if tries >= 5:
+        _LOGGER.error("Could not connect to serial port %s", port)
+        return 1
 
 
 def wrap_to_code(name, comp):
@@ -241,8 +254,7 @@ def upload_using_esptool(config, port):
         if os.environ.get("ESPHOME_USE_SUBPROCESS") is None:
             import esptool
 
-            # pylint: disable=protected-access
-            return run_external_command(esptool._main, *cmd)
+            return run_external_command(esptool.main, *cmd)  # pylint: disable=no-member
 
         return run_external_process(*cmd)
 
@@ -258,9 +270,21 @@ def upload_using_esptool(config, port):
 
 
 def upload_program(config, args, host):
-    # if upload is to a serial port use platformio, otherwise assume ota
     if get_port_type(host) == "SERIAL":
-        return upload_using_esptool(config, host)
+        if CORE.target_platform in (PLATFORM_ESP32, PLATFORM_ESP8266):
+            return upload_using_esptool(config, host)
+
+        if CORE.target_platform in (PLATFORM_RP2040):
+            from esphome import platformio_api
+
+            upload_args = ["-t", "upload"]
+            if args.device is not None:
+                upload_args += ["--upload-port", args.device]
+            return platformio_api.run_platformio_cli_run(
+                config, CORE.verbose, *upload_args
+            )
+
+        return 1  # Unknown target platform
 
     from esphome import espota2
 
@@ -273,6 +297,8 @@ def upload_program(config, args, host):
     ota_conf = config[CONF_OTA]
     remote_port = ota_conf[CONF_PORT]
     password = ota_conf.get(CONF_PASSWORD, "")
+    if getattr(args, "file", None) is not None:
+        return espota2.run_ota(host, remote_port, password, args.file)
     return espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
 
 
@@ -280,8 +306,7 @@ def show_logs(config, args, port):
     if "logger" not in config:
         raise EsphomeError("Logger is not configured!")
     if get_port_type(port) == "SERIAL":
-        run_miniterm(config, port)
-        return 0
+        return run_miniterm(config, port)
     if get_port_type(port) == "NETWORK" and "api" in config:
         from esphome.components.api.client import run_logs
 
@@ -663,6 +688,10 @@ def parse_args(argv):
         "--device",
         help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
     )
+    parser_upload.add_argument(
+        "--file",
+        help="Manually specify the binary file to upload.",
+    )
 
     parser_logs = subparsers.add_parser(
         "logs",

esphome/codegen.py

@@ -22,6 +22,7 @@ from esphome.cpp_generator import (  # noqa
     static_const_array,
     statement,
     variable,
+    with_local_variable,
     new_variable,
     Pvariable,
     new_Pvariable,

esphome/components/adc/adc_sensor.cpp

@@ -11,6 +11,10 @@ ADC_MODE(ADC_VCC)
 #endif
 #endif
 
+#ifdef USE_RP2040
+#include <hardware/adc.h>
+#endif
+
 namespace esphome {
 namespace adc {
 
@@ -32,9 +36,13 @@ static const int ADC_MAX = (1 << SOC_ADC_RTC_MAX_BITWIDTH) - 1;    // 4095 (12 b
 static const int ADC_HALF = (1 << SOC_ADC_RTC_MAX_BITWIDTH) >> 1;  // 2048 (12 bit) or 4096 (13 bit)
 #endif
 
-void ADCSensor::setup() {
+#ifdef USE_RP2040
+extern "C"
+#endif
+    void
+    ADCSensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
-#ifndef USE_ADC_SENSOR_VCC
+#if !defined(USE_ADC_SENSOR_VCC) && !defined(USE_RP2040)
   pin_->setup();
 #endif
 
@@ -63,6 +71,16 @@ void ADCSensor::setup() {
   }
 
 #endif  // USE_ESP32
+
+#ifdef USE_RP2040
+  static bool initialized = false;
+  if (!initialized) {
+    adc_init();
+    initialized = true;
+  }
+#endif
+
+  ESP_LOGCONFIG(TAG, "ADC '%s' setup finished!", this->get_name().c_str());
 }
 
 void ADCSensor::dump_config() {
@@ -98,6 +116,13 @@ void ADCSensor::dump_config() {
     }
   }
 #endif  // USE_ESP32
+#ifdef USE_RP2040
+  if (this->is_temperature_) {
+    ESP_LOGCONFIG(TAG, "  Pin: Temperature");
+  } else {
+    LOG_PIN("  Pin: ", pin_);
+  }
+#endif
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -175,6 +200,29 @@ float ADCSensor::sample() {
 }
 #endif  // USE_ESP32
 
+#ifdef USE_RP2040
+float ADCSensor::sample() {
+  if (this->is_temperature_) {
+    adc_set_temp_sensor_enabled(true);
+    delay(1);
+    adc_select_input(4);
+  } else {
+    uint8_t pin = this->pin_->get_pin();
+    adc_gpio_init(pin);
+    adc_select_input(pin - 26);
+  }
+
+  int raw = adc_read();
+  if (this->is_temperature_) {
+    adc_set_temp_sensor_enabled(false);
+  }
+  if (output_raw_) {
+    return raw;
+  }
+  return raw * 3.3f / 4096.0f;
+}
+#endif
+
 #ifdef USE_ESP8266
 std::string ADCSensor::unique_id() { return get_mac_address() + "-adc"; }
 #endif

esphome/components/adc/adc_sensor.h

@@ -38,10 +38,18 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   std::string unique_id() override;
 #endif
 
+#ifdef USE_RP2040
+  void set_is_temperature() { is_temperature_ = true; }
+#endif
+
  protected:
   InternalGPIOPin *pin_;
   bool output_raw_{false};
 
+#ifdef USE_RP2040
+  bool is_temperature_{false};
+#endif
+
 #ifdef USE_ESP32
   adc_atten_t attenuation_{ADC_ATTEN_DB_0};
   adc1_channel_t channel_{};

esphome/components/adc/sensor.py

@@ -94,6 +94,9 @@ def validate_adc_pin(value):
     if str(value).upper() == "VCC":
         return cv.only_on_esp8266("VCC")
 
+    if str(value).upper() == "TEMPERATURE":
+        return cv.only_on_rp2040("TEMPERATURE")
+
     if CORE.is_esp32:
         value = pins.internal_gpio_input_pin_number(value)
         variant = get_esp32_variant()
@@ -117,6 +120,12 @@ def validate_adc_pin(value):
             {CONF_ANALOG: True, CONF_INPUT: True}, internal=True
         )(value)
 
+    if CORE.is_rp2040:
+        value = pins.internal_gpio_input_pin_number(value)
+        if value 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)
+
     raise NotImplementedError
 
 
@@ -160,6 +169,8 @@ async def to_code(config):
 
     if config[CONF_PIN] == "VCC":
         cg.add_define("USE_ADC_SENSOR_VCC")
+    elif config[CONF_PIN] == "TEMPERATURE":
+        cg.add(var.set_is_temperature())
     else:
         pin = await cg.gpio_pin_expression(config[CONF_PIN])
         cg.add(var.set_pin(pin))

esphome/components/adc128s102/__init__.py

@@ -0,0 +1,23 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import spi
+from esphome.const import CONF_ID
+
+DEPENDENCIES = ["spi"]
+MULTI_CONF = True
+CODEOWNERS = ["@DeerMaximum"]
+
+adc128s102_ns = cg.esphome_ns.namespace("adc128s102")
+ADC128S102 = adc128s102_ns.class_("ADC128S102", cg.Component, spi.SPIDevice)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(ADC128S102),
+    }
+).extend(spi.spi_device_schema(cs_pin_required=True))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await spi.register_spi_device(var, config)

esphome/components/adc128s102/adc128s102.cpp

@@ -0,0 +1,35 @@
+#include "adc128s102.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace adc128s102 {
+
+static const char *const TAG = "adc128s102";
+
+float ADC128S102::get_setup_priority() const { return setup_priority::HARDWARE; }
+
+void ADC128S102::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up adc128s102");
+  this->spi_setup();
+}
+
+void ADC128S102::dump_config() {
+  ESP_LOGCONFIG(TAG, "ADC128S102:");
+  LOG_PIN("  CS Pin:", this->cs_);
+}
+
+uint16_t ADC128S102::read_data(uint8_t channel) {
+  uint8_t control = channel << 3;
+
+  this->enable();
+  uint8_t adc_primary_byte = this->transfer_byte(control);
+  uint8_t adc_secondary_byte = this->transfer_byte(0x00);
+  this->disable();
+
+  uint16_t digital_value = adc_primary_byte << 8 | adc_secondary_byte;
+
+  return digital_value;
+}
+
+}  // namespace adc128s102
+}  // namespace esphome

esphome/components/adc128s102/adc128s102.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/spi/spi.h"
+
+namespace esphome {
+namespace adc128s102 {
+
+class ADC128S102 : public Component,
+                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
+                                         spi::DATA_RATE_10MHZ> {
+ public:
+  ADC128S102() = default;
+
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  uint16_t read_data(uint8_t channel);
+};
+
+}  // namespace adc128s102
+}  // namespace esphome

esphome/components/adc128s102/sensor/__init__.py

@@ -0,0 +1,35 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, voltage_sampler
+from esphome.const import CONF_ID, CONF_CHANNEL
+
+from .. import adc128s102_ns, ADC128S102
+
+AUTO_LOAD = ["voltage_sampler"]
+DEPENDENCIES = ["adc128s102"]
+
+ADC128S102Sensor = adc128s102_ns.class_(
+    "ADC128S102Sensor",
+    sensor.Sensor,
+    cg.PollingComponent,
+    voltage_sampler.VoltageSampler,
+)
+CONF_ADC128S102_ID = "adc128s102_id"
+
+CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(ADC128S102Sensor),
+        cv.GenerateID(CONF_ADC128S102_ID): cv.use_id(ADC128S102),
+        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=7),
+    }
+).extend(cv.polling_component_schema("60s"))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(
+        config[CONF_ID],
+        config[CONF_CHANNEL],
+    )
+    await cg.register_parented(var, config[CONF_ADC128S102_ID])
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)

esphome/components/adc128s102/sensor/adc128s102_sensor.cpp

@@ -0,0 +1,24 @@
+#include "adc128s102_sensor.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace adc128s102 {
+
+static const char *const TAG = "adc128s102.sensor";
+
+ADC128S102Sensor::ADC128S102Sensor(uint8_t channel) : channel_(channel) {}
+
+float ADC128S102Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
+void ADC128S102Sensor::dump_config() {
+  LOG_SENSOR("", "ADC128S102 Sensor", this);
+  ESP_LOGCONFIG(TAG, "  Pin: %u", this->channel_);
+  LOG_UPDATE_INTERVAL(this);
+}
+
+float ADC128S102Sensor::sample() { return this->parent_->read_data(this->channel_); }
+void ADC128S102Sensor::update() { this->publish_state(this->sample()); }
+
+}  // namespace adc128s102
+}  // namespace esphome

esphome/components/adc128s102/sensor/adc128s102_sensor.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/voltage_sampler/voltage_sampler.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+#include "../adc128s102.h"
+
+namespace esphome {
+namespace adc128s102 {
+
+class ADC128S102Sensor : public PollingComponent,
+                         public Parented<ADC128S102>,
+                         public sensor::Sensor,
+                         public voltage_sampler::VoltageSampler {
+ public:
+  ADC128S102Sensor(uint8_t channel);
+
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  float sample() override;
+
+ protected:
+  uint8_t channel_;
+};
+}  // namespace adc128s102
+}  // namespace esphome

esphome/components/addressable_light/addressable_light_display.h

@@ -5,6 +5,8 @@
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/light/addressable_light.h"
 
+#include <vector>
+
 namespace esphome {
 namespace addressable_light {
 

esphome/components/ade7953/ade7953.h

@@ -5,6 +5,8 @@
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/sensor/sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace ade7953 {
 

esphome/components/ads1115/ads1115.h

@@ -5,6 +5,8 @@
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/voltage_sampler/voltage_sampler.h"
 
+#include <vector>
+
 namespace esphome {
 namespace ads1115 {
 

esphome/components/aht10/aht10.cpp

@@ -122,8 +122,9 @@ void AHT10Component::update() {
     this->temperature_sensor_->publish_state(temperature);
   }
   if (this->humidity_sensor_ != nullptr) {
-    if (std::isnan(humidity))
+    if (std::isnan(humidity)) {
       ESP_LOGW(TAG, "Invalid humidity! Sensor reported 0%% Hum");
+    }
     this->humidity_sensor_->publish_state(humidity);
   }
   this->status_clear_warning();

esphome/components/airthings_wave_mini/airthings_wave_mini.cpp

@@ -38,7 +38,7 @@ void AirthingsWaveMini::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt
     }
 
     case ESP_GATTC_READ_CHAR_EVT: {
-      if (param->read.conn_id != this->parent()->conn_id)
+      if (param->read.conn_id != this->parent()->get_conn_id())
         break;
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "Error reading char at handle %d, status=%d", param->read.handle, param->read.status);
@@ -88,8 +88,8 @@ void AirthingsWaveMini::update() {
 }
 
 void AirthingsWaveMini::request_read_values_() {
-  auto status =
-      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle_, ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_read_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->handle_,
+                                        ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     ESP_LOGW(TAG, "Error sending read request for sensor, status=%d", status);
   }

esphome/components/airthings_wave_plus/airthings_wave_plus.cpp

@@ -38,7 +38,7 @@ void AirthingsWavePlus::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt
     }
 
     case ESP_GATTC_READ_CHAR_EVT: {
-      if (param->read.conn_id != this->parent()->conn_id)
+      if (param->read.conn_id != this->parent()->get_conn_id())
         break;
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "Error reading char at handle %d, status=%d", param->read.handle, param->read.status);
@@ -109,8 +109,8 @@ void AirthingsWavePlus::update() {
 }
 
 void AirthingsWavePlus::request_read_values_() {
-  auto status =
-      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle_, ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_read_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->handle_,
+                                        ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     ESP_LOGW(TAG, "Error sending read request for sensor, status=%d", status);
   }

esphome/components/am43/am43.cpp

@@ -76,9 +76,9 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
       if (this->current_sensor_ > 0) {
         if (this->illuminance_ != nullptr) {
           auto *packet = this->encoder_->get_light_level_request();
-          auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
-                                                 packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP,
-                                                 ESP_GATT_AUTH_REQ_NONE);
+          auto status = esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
+                                                 this->char_handle_, packet->length, packet->data,
+                                                 ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
             ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
                      status);
@@ -102,10 +102,11 @@ void Am43::update() {
     if (this->battery_ != nullptr) {
       auto *packet = this->encoder_->get_battery_level_request();
       auto status =
-          esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length,
-                                   packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-      if (status)
+          esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                   packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+      if (status) {
         ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      }
     }
     this->current_sensor_++;
   }

esphome/components/am43/cover/am43_cover.cpp

@@ -27,8 +27,8 @@ void Am43Component::loop() {
   if (this->node_state == espbt::ClientState::ESTABLISHED && !this->logged_in_) {
     auto *packet = this->encoder_->get_send_pin_request(this->pin_);
     auto status =
-        esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length,
-                                 packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     ESP_LOGI(TAG, "[%s] Logging into AM43", this->get_name().c_str());
     if (status) {
       ESP_LOGW(TAG, "[%s] Error writing set_pin to device, error = %d", this->get_name().c_str(), status);
@@ -54,10 +54,11 @@ void Am43Component::control(const CoverCall &call) {
   if (call.get_stop()) {
     auto *packet = this->encoder_->get_stop_request();
     auto status =
-        esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length,
-                                 packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    if (status)
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
       ESP_LOGW(TAG, "[%s] Error writing stop command to device, error = %d", this->get_name().c_str(), status);
+    }
   }
   if (call.get_position().has_value()) {
     auto pos = *call.get_position();
@@ -66,10 +67,11 @@ void Am43Component::control(const CoverCall &call) {
       pos = 1 - pos;
     auto *packet = this->encoder_->get_set_position_request(100 - (uint8_t)(pos * 100));
     auto status =
-        esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length,
-                                 packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    if (status)
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
       ESP_LOGW(TAG, "[%s] Error writing set_position command to device, error = %d", this->get_name().c_str(), status);
+    }
   }
 }
 
@@ -92,7 +94,8 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       }
       this->char_handle_ = chr->handle;
 
-      auto status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->remote_bda, chr->handle);
+      auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
+                                                      chr->handle);
       if (status) {
         ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
       }
@@ -122,21 +125,24 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         if (this->decoder_->pin_ok_) {
           ESP_LOGI(TAG, "[%s] AM43 pin accepted.", this->get_name().c_str());
           auto *packet = this->encoder_->get_position_request();
-          auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
-                                                 packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP,
-                                                 ESP_GATT_AUTH_REQ_NONE);
-          if (status)
+          auto status = esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
+                                                 this->char_handle_, packet->length, packet->data,
+                                                 ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+          if (status) {
             ESP_LOGW(TAG, "[%s] Error writing set_position to device, error = %d", this->get_name().c_str(), status);
+          }
         } else {
           ESP_LOGW(TAG, "[%s] AM43 pin rejected!", this->get_name().c_str());
         }
       }
 
-      if (this->decoder_->has_set_position_response() && !this->decoder_->set_position_ok_)
+      if (this->decoder_->has_set_position_response() && !this->decoder_->set_position_ok_) {
         ESP_LOGW(TAG, "[%s] Got nack after sending set_position. Bad pin?", this->get_name().c_str());
+      }
 
-      if (this->decoder_->has_set_state_response() && !this->decoder_->set_state_ok_)
+      if (this->decoder_->has_set_state_response() && !this->decoder_->set_state_ok_) {
         ESP_LOGW(TAG, "[%s] Got nack after sending set_state. Bad pin?", this->get_name().c_str());
+      }
       break;
     }
     default:

esphome/components/animation/__init__.py

@@ -13,7 +13,7 @@ _LOGGER = logging.getLogger(__name__)
 DEPENDENCIES = ["display"]
 MULTI_CONF = True
 
-Animation_ = display.display_ns.class_("Animation")
+Animation_ = display.display_ns.class_("Animation", espImage.Image_)
 
 ANIMATION_SCHEMA = cv.Schema(
     {

esphome/components/anova/anova.cpp

@@ -34,17 +34,21 @@ void Anova::control(const ClimateCall &call) {
         ESP_LOGW(TAG, "Unsupported mode: %d", mode);
         return;
     }
-    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
-                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    if (status)
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    }
   }
   if (call.get_target_temperature().has_value()) {
     auto *pkt = this->codec_->get_set_target_temp_request(*call.get_target_temperature());
-    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
-                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    if (status)
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    }
   }
 }
 
@@ -65,7 +69,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
       }
       this->char_handle_ = chr->handle;
 
-      auto status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->remote_bda, chr->handle);
+      auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
+                                                      chr->handle);
       if (status) {
         ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
       }
@@ -112,8 +117,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
         }
         if (pkt != nullptr) {
           auto status =
-              esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, pkt->length,
-                                       pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+              esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                       pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
             ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
                      status);
@@ -137,10 +142,12 @@ void Anova::update() {
     auto *pkt = this->codec_->get_read_device_status_request();
     if (this->current_request_ == 0)
       this->codec_->get_set_unit_request(this->fahrenheit_ ? 'f' : 'c');
-    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
-                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    if (status)
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    }
     this->current_request_++;
   }
 }

esphome/components/api/api.proto

@@ -27,7 +27,6 @@ service APIConnection {
   rpc subscribe_logs (SubscribeLogsRequest) returns (void) {}
   rpc subscribe_homeassistant_services (SubscribeHomeassistantServicesRequest) returns (void) {}
   rpc subscribe_home_assistant_states (SubscribeHomeAssistantStatesRequest) returns (void) {}
-  rpc subscribe_bluetooth_le_advertisements (SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
   rpc get_time (GetTimeRequest) returns (GetTimeResponse) {
     option (needs_authentication) = false;
   }
@@ -44,6 +43,16 @@ service APIConnection {
   rpc button_command (ButtonCommandRequest) returns (void) {}
   rpc lock_command (LockCommandRequest) returns (void) {}
   rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
+
+  rpc subscribe_bluetooth_le_advertisements(SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
+  rpc bluetooth_device_request(BluetoothDeviceRequest) returns (void) {}
+  rpc bluetooth_gatt_get_services(BluetoothGATTGetServicesRequest) returns (void) {}
+  rpc bluetooth_gatt_read(BluetoothGATTReadRequest) returns (void) {}
+  rpc bluetooth_gatt_write(BluetoothGATTWriteRequest) returns (void) {}
+  rpc bluetooth_gatt_read_descriptor(BluetoothGATTReadDescriptorRequest) returns (void) {}
+  rpc bluetooth_gatt_write_descriptor(BluetoothGATTWriteDescriptorRequest) returns (void) {}
+  rpc bluetooth_gatt_notify(BluetoothGATTNotifyRequest) returns (void) {}
+  rpc subscribe_bluetooth_connections_free(SubscribeBluetoothConnectionsFreeRequest) returns (BluetoothConnectionsFreeResponse) {}
 }
 
 
@@ -78,6 +87,8 @@ message HelloRequest {
   // Not strictly necessary to send but nice for debugging
   // purposes.
   string client_info = 1;
+  uint32 api_version_major = 2;
+  uint32 api_version_minor = 3;
 }
 
 // Confirmation of successful connection request.
@@ -192,7 +203,9 @@ message DeviceInfoResponse {
 
   uint32 webserver_port = 10;
 
-  bool has_bluetooth_proxy = 11;
+  uint32 bluetooth_proxy_version = 11;
+
+  string manufacturer = 12;
 }
 
 message ListEntitiesRequest {
@@ -902,6 +915,7 @@ message ListEntitiesNumberResponse {
   EntityCategory entity_category = 10;
   string unit_of_measurement = 11;
   NumberMode mode = 12;
+  string device_class = 13;
 }
 message NumberStateResponse {
   option (id) = 50;
@@ -1111,7 +1125,8 @@ message SubscribeBluetoothLEAdvertisementsRequest {
 
 message BluetoothServiceData {
   string uuid = 1;
-  repeated uint32 data = 2 [packed=false];
+  repeated uint32 legacy_data = 2 [deprecated = true];
+  bytes data = 3; // Changed in proto version 1.7
 }
 message BluetoothLEAdvertisementResponse {
   option (id) = 67;
@@ -1126,4 +1141,197 @@ message BluetoothLEAdvertisementResponse {
   repeated string service_uuids = 4;
   repeated BluetoothServiceData service_data = 5;
   repeated BluetoothServiceData manufacturer_data = 6;
+
+  uint32 address_type = 7;
+}
+
+enum BluetoothDeviceRequestType {
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT = 0;
+  BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT = 1;
+  BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR = 2;
+  BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR = 3;
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE = 4;
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE = 5;
+}
+
+message BluetoothDeviceRequest {
+  option (id) = 68;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  BluetoothDeviceRequestType request_type = 2;
+  bool has_address_type = 3;
+  uint32 address_type = 4;
+}
+
+message BluetoothDeviceConnectionResponse {
+  option (id) = 69;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  bool connected = 2;
+  uint32 mtu = 3;
+  int32 error = 4;
+}
+
+message BluetoothGATTGetServicesRequest {
+  option (id) = 70;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+}
+
+message BluetoothGATTDescriptor {
+  repeated uint64 uuid = 1;
+  uint32 handle = 2;
+}
+
+message BluetoothGATTCharacteristic {
+  repeated uint64 uuid = 1;
+  uint32 handle = 2;
+  uint32 properties = 3;
+  repeated BluetoothGATTDescriptor descriptors = 4;
+}
+
+message BluetoothGATTService {
+  repeated uint64 uuid = 1;
+  uint32 handle = 2;
+  repeated BluetoothGATTCharacteristic characteristics = 3;
+}
+
+message BluetoothGATTGetServicesResponse {
+  option (id) = 71;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  repeated BluetoothGATTService services = 2;
+}
+
+message BluetoothGATTGetServicesDoneResponse {
+  option (id) = 72;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+}
+
+message BluetoothGATTReadRequest {
+  option (id) = 73;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+}
+
+message BluetoothGATTReadResponse {
+  option (id) = 74;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+
+  bytes data = 3;
+
+}
+
+message BluetoothGATTWriteRequest {
+  option (id) = 75;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+  bool response = 3;
+
+  bytes data = 4;
+}
+
+message BluetoothGATTReadDescriptorRequest {
+  option (id) = 76;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+}
+
+message BluetoothGATTWriteDescriptorRequest {
+  option (id) = 77;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+
+  bytes data = 3;
+}
+
+message BluetoothGATTNotifyRequest {
+  option (id) = 78;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+  bool enable = 3;
+}
+
+message BluetoothGATTNotifyDataResponse {
+  option (id) = 79;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+
+  bytes data = 3;
+}
+
+message SubscribeBluetoothConnectionsFreeRequest {
+  option (id) = 80;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+}
+
+message BluetoothConnectionsFreeResponse {
+  option (id) = 81;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint32 free = 1;
+  uint32 limit = 2;
+}
+
+message BluetoothGATTErrorResponse {
+  option (id) = 82;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+  int32 error = 3;
+}
+
+message BluetoothGATTWriteResponse {
+  option (id) = 83;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
+}
+
+message BluetoothGATTNotifyResponse {
+  option (id) = 84;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BLUETOOTH_PROXY";
+
+  uint64 address = 1;
+  uint32 handle = 2;
 }

esphome/components/api/api_connection.cpp

@@ -1,10 +1,10 @@
 #include "api_connection.h"
-#include "esphome/core/entity_base.h"
-#include "esphome/core/log.h"
-#include "esphome/components/network/util.h"
-#include "esphome/core/version.h"
-#include "esphome/core/hal.h"
 #include <cerrno>
+#include "esphome/components/network/util.h"
+#include "esphome/core/entity_base.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include "esphome/core/version.h"
 
 #ifdef USE_DEEP_SLEEP
 #include "esphome/components/deep_sleep/deep_sleep_component.h"
@@ -12,6 +12,9 @@
 #ifdef USE_HOMEASSISTANT_TIME
 #include "esphome/components/homeassistant/time/homeassistant_time.h"
 #endif
+#ifdef USE_BLUETOOTH_PROXY
+#include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
+#endif
 
 namespace esphome {
 namespace api {
@@ -613,6 +616,7 @@ bool APIConnection::send_number_info(number::Number *number) {
   msg.entity_category = static_cast<enums::EntityCategory>(number->get_entity_category());
   msg.unit_of_measurement = number->traits.get_unit_of_measurement();
   msg.mode = static_cast<enums::NumberMode>(number->traits.get_mode());
+  msg.device_class = number->traits.get_device_class();
 
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
@@ -823,6 +827,56 @@ void APIConnection::on_get_time_response(const GetTimeResponse &value) {
 }
 #endif
 
+#ifdef USE_BLUETOOTH_PROXY
+bool APIConnection::send_bluetooth_le_advertisement(const BluetoothLEAdvertisementResponse &msg) {
+  if (!this->bluetooth_le_advertisement_subscription_)
+    return false;
+  if (this->client_api_version_major_ < 1 || this->client_api_version_minor_ < 7) {
+    BluetoothLEAdvertisementResponse resp = msg;
+    for (auto &service : resp.service_data) {
+      service.legacy_data.assign(service.data.begin(), service.data.end());
+      service.data.clear();
+    }
+    for (auto &manufacturer_data : resp.manufacturer_data) {
+      manufacturer_data.legacy_data.assign(manufacturer_data.data.begin(), manufacturer_data.data.end());
+      manufacturer_data.data.clear();
+    }
+    return this->send_bluetooth_le_advertisement_response(resp);
+  }
+  return this->send_bluetooth_le_advertisement_response(msg);
+}
+void APIConnection::bluetooth_device_request(const BluetoothDeviceRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_device_request(msg);
+}
+void APIConnection::bluetooth_gatt_read(const BluetoothGATTReadRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_read(msg);
+}
+void APIConnection::bluetooth_gatt_write(const BluetoothGATTWriteRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_write(msg);
+}
+void APIConnection::bluetooth_gatt_read_descriptor(const BluetoothGATTReadDescriptorRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_read_descriptor(msg);
+}
+void APIConnection::bluetooth_gatt_write_descriptor(const BluetoothGATTWriteDescriptorRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_write_descriptor(msg);
+}
+void APIConnection::bluetooth_gatt_get_services(const BluetoothGATTGetServicesRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_send_services(msg);
+}
+
+void APIConnection::bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg) {
+  bluetooth_proxy::global_bluetooth_proxy->bluetooth_gatt_notify(msg);
+}
+
+BluetoothConnectionsFreeResponse APIConnection::subscribe_bluetooth_connections_free(
+    const SubscribeBluetoothConnectionsFreeRequest &msg) {
+  BluetoothConnectionsFreeResponse resp;
+  resp.free = bluetooth_proxy::global_bluetooth_proxy->get_bluetooth_connections_free();
+  resp.limit = bluetooth_proxy::global_bluetooth_proxy->get_bluetooth_connections_limit();
+  return resp;
+}
+#endif
+
 bool APIConnection::send_log_message(int level, const char *tag, const char *line) {
   if (this->log_subscription_ < level)
     return false;
@@ -840,11 +894,14 @@ bool APIConnection::send_log_message(int level, const char *tag, const char *lin
 HelloResponse APIConnection::hello(const HelloRequest &msg) {
   this->client_info_ = msg.client_info + " (" + this->helper_->getpeername() + ")";
   this->helper_->set_log_info(client_info_);
-  ESP_LOGV(TAG, "Hello from client: '%s'", this->client_info_.c_str());
+  this->client_api_version_major_ = msg.api_version_major;
+  this->client_api_version_minor_ = msg.api_version_minor;
+  ESP_LOGV(TAG, "Hello from client: '%s' | API Version %d.%d", this->client_info_.c_str(),
+           this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 6;
+  resp.api_version_minor = 7;
   resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
   resp.name = App.get_name();
 
@@ -876,6 +933,11 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
   resp.mac_address = get_mac_address_pretty();
   resp.esphome_version = ESPHOME_VERSION;
   resp.compilation_time = App.get_compilation_time();
+#if defined(USE_ESP8266) || defined(USE_ESP32)
+  resp.manufacturer = "Espressif";
+#elif defined(USE_RP2040)
+  resp.manufacturer = "Raspberry Pi";
+#endif
   resp.model = ESPHOME_BOARD;
 #ifdef USE_DEEP_SLEEP
   resp.has_deep_sleep = deep_sleep::global_has_deep_sleep;
@@ -888,7 +950,7 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
   resp.webserver_port = USE_WEBSERVER_PORT;
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  resp.has_bluetooth_proxy = true;
+  resp.bluetooth_proxy_version = bluetooth_proxy::global_bluetooth_proxy->has_active() ? 3 : 1;
 #endif
   return resp;
 }

esphome/components/api/api_connection.h

@@ -1,15 +1,13 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/core/application.h"
+#include "api_frame_helper.h"
 #include "api_pb2.h"
 #include "api_pb2_service.h"
 #include "api_server.h"
-#include "api_frame_helper.h"
+#include "esphome/core/application.h"
+#include "esphome/core/component.h"
 
-#ifdef USE_BLUETOOTH_PROXY
-#include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
-#endif
+#include <vector>
 
 namespace esphome {
 namespace api {
@@ -99,11 +97,18 @@ class APIConnection : public APIServerConnection {
     this->send_homeassistant_service_response(call);
   }
 #ifdef USE_BLUETOOTH_PROXY
-  bool send_bluetooth_le_advertisement(const BluetoothLEAdvertisementResponse &call) {
-    if (!this->bluetooth_le_advertisement_subscription_)
-      return false;
-    return this->send_bluetooth_le_advertisement_response(call);
-  }
+  bool send_bluetooth_le_advertisement(const BluetoothLEAdvertisementResponse &msg);
+
+  void bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
+  void bluetooth_gatt_read(const BluetoothGATTReadRequest &msg) override;
+  void bluetooth_gatt_write(const BluetoothGATTWriteRequest &msg) override;
+  void bluetooth_gatt_read_descriptor(const BluetoothGATTReadDescriptorRequest &msg) override;
+  void bluetooth_gatt_write_descriptor(const BluetoothGATTWriteDescriptorRequest &msg) override;
+  void bluetooth_gatt_get_services(const BluetoothGATTGetServicesRequest &msg) override;
+  void bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg) override;
+  BluetoothConnectionsFreeResponse subscribe_bluetooth_connections_free(
+      const SubscribeBluetoothConnectionsFreeRequest &msg) override;
+
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   void send_time_request() {
@@ -181,6 +186,8 @@ class APIConnection : public APIServerConnection {
   std::unique_ptr<APIFrameHelper> helper_;
 
   std::string client_info_;
+  uint32_t client_api_version_major_{0};
+  uint32_t client_api_version_minor_{0};
 #ifdef USE_ESP32_CAMERA
   esp32_camera::CameraImageReader image_reader_;
 #endif
@@ -190,7 +197,7 @@ class APIConnection : public APIServerConnection {
   uint32_t last_traffic_;
   bool sent_ping_{false};
   bool service_call_subscription_{false};
-  bool bluetooth_le_advertisement_subscription_{true};
+  bool bluetooth_le_advertisement_subscription_{false};
   bool next_close_ = false;
   APIServer *parent_;
   InitialStateIterator initial_state_iterator_;

esphome/components/api/api_pb2.h

@@ -155,12 +155,22 @@ enum MediaPlayerCommand : uint32_t {
   MEDIA_PLAYER_COMMAND_MUTE = 3,
   MEDIA_PLAYER_COMMAND_UNMUTE = 4,
 };
+enum BluetoothDeviceRequestType : uint32_t {
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT = 0,
+  BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT = 1,
+  BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR = 2,
+  BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR = 3,
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE = 4,
+  BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE = 5,
+};
 
 }  // namespace enums
 
 class HelloRequest : public ProtoMessage {
  public:
   std::string client_info{};
+  uint32_t api_version_major{0};
+  uint32_t api_version_minor{0};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -168,6 +178,7 @@ class HelloRequest : public ProtoMessage {
 
  protected:
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class HelloResponse : public ProtoMessage {
  public:
@@ -263,7 +274,8 @@ class DeviceInfoResponse : public ProtoMessage {
   std::string project_name{};
   std::string project_version{};
   uint32_t webserver_port{0};
-  bool has_bluetooth_proxy{false};
+  uint32_t bluetooth_proxy_version{0};
+  std::string manufacturer{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -994,6 +1006,7 @@ class ListEntitiesNumberResponse : public ProtoMessage {
   enums::EntityCategory entity_category{};
   std::string unit_of_measurement{};
   enums::NumberMode mode{};
+  std::string device_class{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1227,7 +1240,8 @@ class SubscribeBluetoothLEAdvertisementsRequest : public ProtoMessage {
 class BluetoothServiceData : public ProtoMessage {
  public:
   std::string uuid{};
-  std::vector<uint32_t> data{};
+  std::vector<uint32_t> legacy_data{};
+  std::string data{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1245,6 +1259,7 @@ class BluetoothLEAdvertisementResponse : public ProtoMessage {
   std::vector<std::string> service_uuids{};
   std::vector<BluetoothServiceData> service_data{};
   std::vector<BluetoothServiceData> manufacturer_data{};
+  uint32_t address_type{0};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1254,6 +1269,262 @@ class BluetoothLEAdvertisementResponse : public ProtoMessage {
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class BluetoothDeviceRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  enums::BluetoothDeviceRequestType request_type{};
+  bool has_address_type{false};
+  uint32_t address_type{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothDeviceConnectionResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  bool connected{false};
+  uint32_t mtu{0};
+  int32_t error{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTGetServicesRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTDescriptor : public ProtoMessage {
+ public:
+  std::vector<uint64_t> uuid{};
+  uint32_t handle{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTCharacteristic : public ProtoMessage {
+ public:
+  std::vector<uint64_t> uuid{};
+  uint32_t handle{0};
+  uint32_t properties{0};
+  std::vector<BluetoothGATTDescriptor> descriptors{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTService : public ProtoMessage {
+ public:
+  std::vector<uint64_t> uuid{};
+  uint32_t handle{0};
+  std::vector<BluetoothGATTCharacteristic> characteristics{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTGetServicesResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  std::vector<BluetoothGATTService> services{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTGetServicesDoneResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTReadRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTReadResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  std::string data{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTWriteRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  bool response{false};
+  std::string data{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTReadDescriptorRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTWriteDescriptorRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  std::string data{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTNotifyRequest : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  bool enable{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTNotifyDataResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  std::string data{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SubscribeBluetoothConnectionsFreeRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+};
+class BluetoothConnectionsFreeResponse : public ProtoMessage {
+ public:
+  uint32_t free{0};
+  uint32_t limit{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTErrorResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  int32_t error{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTWriteResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class BluetoothGATTNotifyResponse : public ProtoMessage {
+ public:
+  uint64_t address{0};
+  uint32_t handle{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -336,6 +336,95 @@ bool APIServerConnectionBase::send_bluetooth_le_advertisement_response(const Blu
   return this->send_message_<BluetoothLEAdvertisementResponse>(msg, 67);
 }
 #endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_device_connection_response(const BluetoothDeviceConnectionResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_device_connection_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothDeviceConnectionResponse>(msg, 69);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_get_services_response(const BluetoothGATTGetServicesResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_get_services_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTGetServicesResponse>(msg, 71);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_get_services_done_response(
+    const BluetoothGATTGetServicesDoneResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_get_services_done_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTGetServicesDoneResponse>(msg, 72);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_read_response(const BluetoothGATTReadResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_read_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTReadResponse>(msg, 74);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_notify_data_response(const BluetoothGATTNotifyDataResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_notify_data_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTNotifyDataResponse>(msg, 79);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_connections_free_response(const BluetoothConnectionsFreeResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_connections_free_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothConnectionsFreeResponse>(msg, 81);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_error_response(const BluetoothGATTErrorResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_error_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTErrorResponse>(msg, 82);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_write_response(const BluetoothGATTWriteResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_write_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTWriteResponse>(msg, 83);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+bool APIServerConnectionBase::send_bluetooth_gatt_notify_response(const BluetoothGATTNotifyResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_bluetooth_gatt_notify_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<BluetoothGATTNotifyResponse>(msg, 84);
+}
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -612,6 +701,94 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_subscribe_bluetooth_le_advertisements_request(msg);
       break;
     }
+    case 68: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothDeviceRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_device_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_device_request(msg);
+#endif
+      break;
+    }
+    case 70: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTGetServicesRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_get_services_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_get_services_request(msg);
+#endif
+      break;
+    }
+    case 73: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTReadRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_read_request(msg);
+#endif
+      break;
+    }
+    case 75: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTWriteRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_write_request(msg);
+#endif
+      break;
+    }
+    case 76: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTReadDescriptorRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_descriptor_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_read_descriptor_request(msg);
+#endif
+      break;
+    }
+    case 77: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTWriteDescriptorRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_descriptor_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_write_descriptor_request(msg);
+#endif
+      break;
+    }
+    case 78: {
+#ifdef USE_BLUETOOTH_PROXY
+      BluetoothGATTNotifyRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_notify_request: %s", msg.dump().c_str());
+#endif
+      this->on_bluetooth_gatt_notify_request(msg);
+#endif
+      break;
+    }
+    case 80: {
+#ifdef USE_BLUETOOTH_PROXY
+      SubscribeBluetoothConnectionsFreeRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_subscribe_bluetooth_connections_free_request: %s", msg.dump().c_str());
+#endif
+      this->on_subscribe_bluetooth_connections_free_request(msg);
+#endif
+      break;
+    }
     default:
       return false;
   }
@@ -708,18 +885,6 @@ void APIServerConnection::on_subscribe_home_assistant_states_request(const Subsc
   }
   this->subscribe_home_assistant_states(msg);
 }
-void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
-    const SubscribeBluetoothLEAdvertisementsRequest &msg) {
-  if (!this->is_connection_setup()) {
-    this->on_no_setup_connection();
-    return;
-  }
-  if (!this->is_authenticated()) {
-    this->on_unauthenticated_access();
-    return;
-  }
-  this->subscribe_bluetooth_le_advertisements(msg);
-}
 void APIServerConnection::on_get_time_request(const GetTimeRequest &msg) {
   if (!this->is_connection_setup()) {
     this->on_no_setup_connection();
@@ -884,6 +1049,126 @@ void APIServerConnection::on_media_player_command_request(const MediaPlayerComma
   this->media_player_command(msg);
 }
 #endif
+void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
+    const SubscribeBluetoothLEAdvertisementsRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->subscribe_bluetooth_le_advertisements(msg);
+}
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_device_request(const BluetoothDeviceRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_device_request(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_get_services(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_read(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_write(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_read_descriptor(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_write_descriptor(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->bluetooth_gatt_notify(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_subscribe_bluetooth_connections_free_request(
+    const SubscribeBluetoothConnectionsFreeRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  BluetoothConnectionsFreeResponse ret = this->subscribe_bluetooth_connections_free(msg);
+  if (!this->send_bluetooth_connections_free_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -158,6 +158,57 @@ class APIServerConnectionBase : public ProtoService {
       const SubscribeBluetoothLEAdvertisementsRequest &value){};
 #ifdef USE_BLUETOOTH_PROXY
   bool send_bluetooth_le_advertisement_response(const BluetoothLEAdvertisementResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_device_request(const BluetoothDeviceRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_device_connection_response(const BluetoothDeviceConnectionResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_get_services_response(const BluetoothGATTGetServicesResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_get_services_done_response(const BluetoothGATTGetServicesDoneResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_read_response(const BluetoothGATTReadResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_notify_data_response(const BluetoothGATTNotifyDataResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void on_subscribe_bluetooth_connections_free_request(const SubscribeBluetoothConnectionsFreeRequest &value){};
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_connections_free_response(const BluetoothConnectionsFreeResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_error_response(const BluetoothGATTErrorResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_write_response(const BluetoothGATTWriteResponse &msg);
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  bool send_bluetooth_gatt_notify_response(const BluetoothGATTNotifyResponse &msg);
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -175,7 +226,6 @@ class APIServerConnection : public APIServerConnectionBase {
   virtual void subscribe_logs(const SubscribeLogsRequest &msg) = 0;
   virtual void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) = 0;
   virtual void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) = 0;
-  virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
   virtual GetTimeResponse get_time(const GetTimeRequest &msg) = 0;
   virtual void execute_service(const ExecuteServiceRequest &msg) = 0;
 #ifdef USE_COVER
@@ -210,6 +260,32 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_MEDIA_PLAYER
   virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
+#endif
+  virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_device_request(const BluetoothDeviceRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_get_services(const BluetoothGATTGetServicesRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_read(const BluetoothGATTReadRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_write(const BluetoothGATTWriteRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_read_descriptor(const BluetoothGATTReadDescriptorRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_write_descriptor(const BluetoothGATTWriteDescriptorRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual BluetoothConnectionsFreeResponse subscribe_bluetooth_connections_free(
+      const SubscribeBluetoothConnectionsFreeRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -222,7 +298,6 @@ class APIServerConnection : public APIServerConnectionBase {
   void on_subscribe_logs_request(const SubscribeLogsRequest &msg) override;
   void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &msg) override;
   void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) override;
-  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
   void on_get_time_request(const GetTimeRequest &msg) override;
   void on_execute_service_request(const ExecuteServiceRequest &msg) override;
 #ifdef USE_COVER
@@ -257,6 +332,31 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_MEDIA_PLAYER
   void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
+  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_subscribe_bluetooth_connections_free_request(const SubscribeBluetoothConnectionsFreeRequest &msg) override;
 #endif
 };
 

esphome/components/api/api_server.cpp

@@ -297,6 +297,72 @@ void APIServer::send_bluetooth_le_advertisement(const BluetoothLEAdvertisementRe
     client->send_bluetooth_le_advertisement(call);
   }
 }
+void APIServer::send_bluetooth_device_connection(uint64_t address, bool connected, uint16_t mtu, esp_err_t error) {
+  BluetoothDeviceConnectionResponse call;
+  call.address = address;
+  call.connected = connected;
+  call.mtu = mtu;
+  call.error = error;
+
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_device_connection_response(call);
+  }
+}
+
+void APIServer::send_bluetooth_connections_free(uint8_t free, uint8_t limit) {
+  BluetoothConnectionsFreeResponse call;
+  call.free = free;
+  call.limit = limit;
+
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_connections_free_response(call);
+  }
+}
+
+void APIServer::send_bluetooth_gatt_read_response(const BluetoothGATTReadResponse &call) {
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_read_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_write_response(const BluetoothGATTWriteResponse &call) {
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_write_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_notify_data_response(const BluetoothGATTNotifyDataResponse &call) {
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_notify_data_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_notify_response(const BluetoothGATTNotifyResponse &call) {
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_notify_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_services(const BluetoothGATTGetServicesResponse &call) {
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_get_services_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_services_done(uint64_t address) {
+  BluetoothGATTGetServicesDoneResponse call;
+  call.address = address;
+
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_get_services_done_response(call);
+  }
+}
+void APIServer::send_bluetooth_gatt_error(uint64_t address, uint16_t handle, esp_err_t error) {
+  BluetoothGATTErrorResponse call;
+  call.address = address;
+  call.handle = handle;
+  call.error = error;
+
+  for (auto &client : this->clients_) {
+    client->send_bluetooth_gatt_error_response(call);
+  }
+}
+
 #endif
 APIServer::APIServer() { global_api_server = this; }
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,

esphome/components/api/api_server.h

@@ -12,6 +12,8 @@
 #include "user_services.h"
 #include "api_noise_context.h"
 
+#include <vector>
+
 namespace esphome {
 namespace api {
 
@@ -75,6 +77,15 @@ class APIServer : public Component, public Controller {
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
 #ifdef USE_BLUETOOTH_PROXY
   void send_bluetooth_le_advertisement(const BluetoothLEAdvertisementResponse &call);
+  void send_bluetooth_device_connection(uint64_t address, bool connected, uint16_t mtu = 0, esp_err_t error = ESP_OK);
+  void send_bluetooth_connections_free(uint8_t free, uint8_t limit);
+  void send_bluetooth_gatt_read_response(const BluetoothGATTReadResponse &call);
+  void send_bluetooth_gatt_write_response(const BluetoothGATTWriteResponse &call);
+  void send_bluetooth_gatt_notify_data_response(const BluetoothGATTNotifyDataResponse &call);
+  void send_bluetooth_gatt_notify_response(const BluetoothGATTNotifyResponse &call);
+  void send_bluetooth_gatt_services(const BluetoothGATTGetServicesResponse &call);
+  void send_bluetooth_gatt_services_done(uint64_t address);
+  void send_bluetooth_gatt_error(uint64_t address, uint16_t handle, esp_err_t error);
 #endif
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
 #ifdef USE_HOMEASSISTANT_TIME

esphome/components/api/homeassistant_service.h

@@ -5,6 +5,8 @@
 #include "api_pb2.h"
 #include "api_server.h"
 
+#include <vector>
+
 namespace esphome {
 namespace api {
 

esphome/components/api/proto.h

@@ -4,6 +4,8 @@
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
 
+#include <vector>
+
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
 #define HAS_PROTO_MESSAGE_DUMP
 #endif

esphome/components/api/user_services.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <utility>
+#include <vector>
 
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"

esphome/components/async_tcp/__init__.py

@@ -8,6 +8,7 @@ CODEOWNERS = ["@OttoWinter"]
 CONFIG_SCHEMA = cv.All(
     cv.Schema({}),
     cv.only_with_arduino,
+    cv.only_on(["esp32", "esp8266"]),
 )
 
 

esphome/components/atc_mithermometer/atc_mithermometer.h

@@ -4,6 +4,8 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 
+#include <vector>
+
 #ifdef USE_ESP32
 
 namespace esphome {

esphome/components/bedjet/bedjet_hub.cpp

@@ -128,9 +128,9 @@ uint8_t BedJetHub::write_bedjet_packet_(BedjetPacket *pkt) {
     }
     return -1;
   }
-  auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_cmd_,
-                                         pkt->data_length + 1, (uint8_t *) &pkt->command, ESP_GATT_WRITE_TYPE_NO_RSP,
-                                         ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
+                                         this->char_handle_cmd_, pkt->data_length + 1, (uint8_t *) &pkt->command,
+                                         ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   return status;
 }
 
@@ -138,13 +138,13 @@ uint8_t BedJetHub::write_bedjet_packet_(BedjetPacket *pkt) {
 uint8_t BedJetHub::set_notify_(const bool enable) {
   uint8_t status;
   if (enable) {
-    status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->remote_bda,
+    status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                                this->char_handle_status_);
     if (status) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
     }
   } else {
-    status = esp_ble_gattc_unregister_for_notify(this->parent_->gattc_if, this->parent_->remote_bda,
+    status = esp_ble_gattc_unregister_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                                  this->char_handle_status_);
     if (status) {
       ESP_LOGW(TAG, "[%s] esp_ble_gattc_unregister_for_notify failed, status=%d", this->get_name().c_str(), status);
@@ -204,8 +204,8 @@ bool BedJetHub::discover_characteristics_() {
       result = false;
     } else {
       this->char_handle_name_ = chr->handle;
-      auto status = esp_ble_gattc_read_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_name_,
-                                            ESP_GATT_AUTH_REQ_NONE);
+      auto status = esp_ble_gattc_read_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
+                                            this->char_handle_name_, ESP_GATT_AUTH_REQ_NONE);
       if (status) {
         ESP_LOGI(TAG, "[%s] Unable to read name characteristic: %d", this->get_name().c_str(), status);
       }
@@ -230,22 +230,6 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       this->dispatch_state_(false);
       break;
     }
-    case ESP_GATTC_OPEN_EVT: {
-      // FIXME: bug in BLEClient
-      this->parent_->conn_id = param->open.conn_id;
-      this->open_conn_id_ = param->open.conn_id;
-      break;
-    }
-
-    case ESP_GATTC_CONNECT_EVT: {
-      if (this->parent_->conn_id != param->connect.conn_id && this->open_conn_id_ != 0xff) {
-        // FIXME: bug in BLEClient
-        ESP_LOGW(TAG, "[%s] CONNECT_EVT unexpected conn_id; open=%d, parent=%d, param=%d", this->get_name().c_str(),
-                 this->open_conn_id_, this->parent_->conn_id, param->connect.conn_id);
-        this->parent_->conn_id = this->open_conn_id_;
-      }
-      break;
-    }
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto result = this->discover_characteristics_();
 
@@ -301,7 +285,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       break;
     }
     case ESP_GATTC_READ_CHAR_EVT: {
-      if (param->read.conn_id != this->parent_->conn_id)
+      if (param->read.conn_id != this->parent_->get_conn_id())
         break;
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "Error reading char at handle %d, status=%d", param->read.handle, param->read.status);
@@ -358,9 +342,9 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       if (this->processing_)
         break;
 
-      if (param->notify.conn_id != this->parent_->conn_id) {
+      if (param->notify.conn_id != this->parent_->get_conn_id()) {
         ESP_LOGW(TAG, "[%s] Received notify event for unexpected parent conn: expect %x, got %x",
-                 this->get_name().c_str(), this->parent_->conn_id, param->notify.conn_id);
+                 this->get_name().c_str(), this->parent_->get_conn_id(), param->notify.conn_id);
         // FIXME: bug in BLEClient holding wrong conn_id.
       }
 
@@ -394,7 +378,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         if (needs_extra) {
           // This means the packet was partial, so read the status characteristic to get the second part.
           // Ideally this will complete quickly. We won't process additional notification events until it does.
-          auto status = esp_ble_gattc_read_char(this->parent_->gattc_if, this->parent_->conn_id,
+          auto status = esp_ble_gattc_read_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
                                                 this->char_handle_status_, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
             ESP_LOGI(TAG, "[%s] Unable to read extended status packet", this->get_name().c_str());
@@ -438,15 +422,15 @@ uint8_t BedJetHub::write_notify_config_descriptor_(bool enable) {
 
   // NOTE: BLEClient uses `uint8_t*` of length 1, but BLE spec requires 16 bits.
   uint16_t notify_en = enable ? 1 : 0;
-  auto status =
-      esp_ble_gattc_write_char_descr(this->parent_->gattc_if, this->parent_->conn_id, handle, sizeof(notify_en),
-                                     (uint8_t *) &notify_en, ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_write_char_descr(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), handle,
+                                               sizeof(notify_en), (uint8_t *) &notify_en, ESP_GATT_WRITE_TYPE_RSP,
+                                               ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
     return status;
   }
   ESP_LOGD(TAG, "[%s] wrote notify=%s to status config 0x%04x, for conn %d", this->get_name().c_str(),
-           enable ? "true" : "false", handle, this->parent_->conn_id);
+           enable ? "true" : "false", handle, this->parent_->get_conn_id());
   return ESP_GATT_OK;
 }
 
@@ -500,7 +484,7 @@ void BedJetHub::update() { this->dispatch_status_(); }
 void BedJetHub::dump_config() {
   ESP_LOGCONFIG(TAG, "BedJet Hub '%s'", this->get_name().c_str());
   ESP_LOGCONFIG(TAG, "  ble_client.app_id: %d", this->parent()->app_id);
-  ESP_LOGCONFIG(TAG, "  ble_client.conn_id: %d", this->parent()->conn_id);
+  ESP_LOGCONFIG(TAG, "  ble_client.conn_id: %d", this->parent()->get_conn_id());
   LOG_UPDATE_INTERVAL(this)
   ESP_LOGCONFIG(TAG, "  Child components (%d):", this->children_.size());
   for (auto *child : this->children_) {

esphome/components/bedjet/bedjet_hub.h

@@ -8,6 +8,8 @@
 #include "bedjet_child.h"
 #include "bedjet_codec.h"
 
+#include <vector>
+
 #ifdef USE_TIME
 #include "esphome/components/time/real_time_clock.h"
 #endif
@@ -167,8 +169,6 @@ class BedJetHub : public esphome::ble_client::BLEClientNode, public PollingCompo
   uint16_t char_handle_status_;
   uint16_t config_descr_status_;
 
-  uint8_t open_conn_id_ = -1;
-
   uint8_t write_notify_config_descriptor_(bool enable);
 };
 

esphome/components/binary_sensor/automation.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <utility>
+#include <vector>
 
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"

esphome/components/binary_sensor/binary_sensor.h

@@ -5,6 +5,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/filter.h"
 
+#include <vector>
+
 namespace esphome {
 
 namespace binary_sensor {

esphome/components/binary_sensor/filter.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
+#include <vector>
+
 namespace esphome {
 
 namespace binary_sensor {

esphome/components/binary_sensor_map/binary_sensor_map.h

@@ -4,6 +4,8 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/components/sensor/sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace binary_sensor_map {
 

esphome/components/ble_client/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import esp32_ble_tracker
+from esphome.components import esp32_ble_tracker, esp32_ble_client
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
     CONF_ID,
@@ -14,13 +14,12 @@ from esphome.const import (
 )
 from esphome import automation
 
+AUTO_LOAD = ["esp32_ble_client"]
 CODEOWNERS = ["@buxtronix"]
 DEPENDENCIES = ["esp32_ble_tracker"]
 
 ble_client_ns = cg.esphome_ns.namespace("ble_client")
-BLEClient = ble_client_ns.class_(
-    "BLEClient", cg.Component, esp32_ble_tracker.ESPBTClient
-)
+BLEClient = ble_client_ns.class_("BLEClient", esp32_ble_client.BLEClientBase)
 BLEClientNode = ble_client_ns.class_("BLEClientNode")
 BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
 # Triggers
@@ -67,7 +66,7 @@ CONF_BLE_CLIENT_ID = "ble_client_id"
 
 BLE_CLIENT_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
     }
 )
 
@@ -79,7 +78,7 @@ async def register_ble_node(var, config):
 
 BLE_WRITE_ACTION_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_ID): cv.use_id(BLEClient),
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
         cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
         cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
         cv.Required(CONF_VALUE): cv.templatable(cv.ensure_list(cv.hex_uint8_t)),
@@ -101,12 +100,40 @@ async def ble_write_to_code(config, action_id, template_arg, args):
     else:
         cg.add(var.set_value_simple(value))
 
-    serv_uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
-    cg.add(var.set_service_uuid128(serv_uuid128))
-    char_uuid128 = esp32_ble_tracker.as_reversed_hex_array(
-        config[CONF_CHARACTERISTIC_UUID]
-    )
-    cg.add(var.set_char_uuid128(char_uuid128))
+    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+        cg.add(
+            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
+        cg.add(var.set_service_uuid128(uuid128))
+
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_char_uuid16(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid32_format
+    ):
+        cg.add(
+            var.set_char_uuid32(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid128_format
+    ):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(
+            config[CONF_CHARACTERISTIC_UUID]
+        )
+        cg.add(var.set_char_uuid128(uuid128))
+
     return var
 
 

esphome/components/ble_client/automation.cpp

@@ -1,8 +1,8 @@
 #include "automation.h"
 
+#include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gattc_api.h>
-#include <esp_bt_defs.h>
 
 #include "esphome/core/log.h"
 
@@ -31,8 +31,8 @@ void BLEWriterClientNode::write(const std::vector<uint8_t> &value) {
   }
   ESP_LOGVV(TAG, "Will write %d bytes: %s", value.size(), format_hex_pretty(value).c_str());
   esp_err_t err =
-      esp_ble_gattc_write_char(this->parent()->gattc_if, this->parent()->conn_id, this->ble_char_handle_, value.size(),
-                               const_cast<uint8_t *>(value.data()), write_type, ESP_GATT_AUTH_REQ_NONE);
+      esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->ble_char_handle_,
+                               value.size(), const_cast<uint8_t *>(value.data()), write_type, ESP_GATT_AUTH_REQ_NONE);
   if (err != ESP_OK) {
     ESP_LOGE(TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
   }

esphome/components/ble_client/automation.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <utility>
+#include <vector>
 
 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
@@ -28,7 +29,8 @@ class BLEClientDisconnectTrigger : public Trigger<>, public BLEClientNode {
   void loop() override {}
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override {
-    if (event == ESP_GATTC_DISCONNECT_EVT && memcmp(param->disconnect.remote_bda, this->parent_->remote_bda, 6) == 0)
+    if (event == ESP_GATTC_DISCONNECT_EVT &&
+        memcmp(param->disconnect.remote_bda, this->parent_->get_remote_bda(), 6) == 0)
       this->trigger();
     if (event == ESP_GATTC_SEARCH_CMPL_EVT)
       this->node_state = espbt::ClientState::ESTABLISHED;
@@ -45,10 +47,14 @@ class BLEWriterClientNode : public BLEClientNode {
   // Attempts to write the contents of value to char_uuid_.
   void write(const std::vector<uint8_t> &value);
 
-  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
   void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
 
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;
 

esphome/components/ble_client/ble_client.cpp

@@ -1,8 +1,9 @@
-#include "esphome/core/log.h"
+#include "ble_client.h"
+#include "esphome/components/esp32_ble_client/ble_client_base.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
-#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
-#include "ble_client.h"
+#include "esphome/core/log.h"
 
 #ifdef USE_ESP32
 
@@ -11,22 +12,13 @@ namespace ble_client {
 
 static const char *const TAG = "ble_client";
 
-float BLEClient::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
-
 void BLEClient::setup() {
-  auto ret = esp_ble_gattc_app_register(this->app_id);
-  if (ret) {
-    ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
-    this->mark_failed();
-  }
-  this->set_states_(espbt::ClientState::IDLE);
+  BLEClientBase::setup();
   this->enabled = true;
 }
 
 void BLEClient::loop() {
-  if (this->state() == espbt::ClientState::DISCOVERED) {
-    this->connect();
-  }
+  BLEClientBase::loop();
   for (auto *node : this->nodes_)
     node->loop();
 }
@@ -39,34 +31,7 @@ void BLEClient::dump_config() {
 bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
   if (!this->enabled)
     return false;
-  if (device.address_uint64() != this->address)
-    return false;
-  if (this->state() != espbt::ClientState::IDLE)
-    return false;
-
-  ESP_LOGD(TAG, "Found device at MAC address [%s]", device.address_str().c_str());
-  this->set_states_(espbt::ClientState::DISCOVERED);
-
-  auto addr = device.address_uint64();
-  this->remote_bda[0] = (addr >> 40) & 0xFF;
-  this->remote_bda[1] = (addr >> 32) & 0xFF;
-  this->remote_bda[2] = (addr >> 24) & 0xFF;
-  this->remote_bda[3] = (addr >> 16) & 0xFF;
-  this->remote_bda[4] = (addr >> 8) & 0xFF;
-  this->remote_bda[5] = (addr >> 0) & 0xFF;
-  this->remote_addr_type = device.get_address_type();
-  return true;
-}
-
-std::string BLEClient::address_str() const {
-  char buf[20];
-  sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x", (uint8_t)(this->address >> 40) & 0xff,
-          (uint8_t)(this->address >> 32) & 0xff, (uint8_t)(this->address >> 24) & 0xff,
-          (uint8_t)(this->address >> 16) & 0xff, (uint8_t)(this->address >> 8) & 0xff,
-          (uint8_t)(this->address >> 0) & 0xff);
-  std::string ret;
-  ret = buf;
-  return ret;
+  return BLEClientBase::parse_device(device);
 }
 
 void BLEClient::set_enabled(bool enabled) {
@@ -74,7 +39,7 @@ void BLEClient::set_enabled(bool enabled) {
     return;
   if (!enabled && this->state() != espbt::ClientState::IDLE) {
     ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str());
-    auto ret = esp_ble_gattc_close(this->gattc_if, this->conn_id);
+    auto ret = esp_ble_gattc_close(this->gattc_if_, this->conn_id_);
     if (ret) {
       ESP_LOGW(TAG, "esp_ble_gattc_close error, address=%s status=%d", this->address_str().c_str(), ret);
     }
@@ -82,125 +47,13 @@ void BLEClient::set_enabled(bool enabled) {
   this->enabled = enabled;
 }
 
-void BLEClient::connect() {
-  ESP_LOGI(TAG, "Attempting BLE connection to %s", this->address_str().c_str());
-  auto ret = esp_ble_gattc_open(this->gattc_if, this->remote_bda, this->remote_addr_type, true);
-  if (ret) {
-    ESP_LOGW(TAG, "esp_ble_gattc_open error, address=%s status=%d", this->address_str().c_str(), ret);
-    this->set_states_(espbt::ClientState::IDLE);
-  } else {
-    this->set_states_(espbt::ClientState::CONNECTING);
-  }
-}
-
-void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
+bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
                                     esp_ble_gattc_cb_param_t *param) {
-  if (event == ESP_GATTC_REG_EVT && this->app_id != param->reg.app_id)
-    return;
-  if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if)
-    return;
-
   bool all_established = this->all_nodes_established_();
 
-  switch (event) {
-    case ESP_GATTC_REG_EVT: {
-      if (param->reg.status == ESP_GATT_OK) {
-        ESP_LOGV(TAG, "gattc registered app id %d", this->app_id);
-        this->gattc_if = esp_gattc_if;
-      } else {
-        ESP_LOGE(TAG, "gattc app registration failed id=%d code=%d", param->reg.app_id, param->reg.status);
-      }
-      break;
-    }
-    case ESP_GATTC_OPEN_EVT: {
-      ESP_LOGV(TAG, "[%s] ESP_GATTC_OPEN_EVT", this->address_str().c_str());
-      this->conn_id = param->open.conn_id;
-      if (param->open.status != ESP_GATT_OK) {
-        ESP_LOGW(TAG, "connect to %s failed, status=%d", this->address_str().c_str(), param->open.status);
-        this->set_states_(espbt::ClientState::IDLE);
-        break;
-      }
-      break;
-    }
-    case ESP_GATTC_CONNECT_EVT: {
-      ESP_LOGV(TAG, "[%s] ESP_GATTC_CONNECT_EVT", this->address_str().c_str());
-      if (this->conn_id != param->connect.conn_id) {
-        ESP_LOGD(TAG, "[%s] Unexpected conn_id in CONNECT_EVT: param conn=%d, open conn=%d",
-                 this->address_str().c_str(), param->connect.conn_id, this->conn_id);
-      }
-      auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if, param->connect.conn_id);
-      if (ret) {
-        ESP_LOGW(TAG, "esp_ble_gattc_send_mtu_req failed, status=%x", ret);
-      }
-      break;
-    }
-    case ESP_GATTC_CFG_MTU_EVT: {
-      if (param->cfg_mtu.status != ESP_GATT_OK) {
-        ESP_LOGW(TAG, "cfg_mtu to %s failed, mtu %d, status %d", this->address_str().c_str(), param->cfg_mtu.mtu,
-                 param->cfg_mtu.status);
-        this->set_states_(espbt::ClientState::IDLE);
-        break;
-      }
-      ESP_LOGV(TAG, "cfg_mtu status %d, mtu %d", param->cfg_mtu.status, param->cfg_mtu.mtu);
-      esp_ble_gattc_search_service(esp_gattc_if, param->cfg_mtu.conn_id, nullptr);
-      break;
-    }
-    case ESP_GATTC_DISCONNECT_EVT: {
-      if (memcmp(param->disconnect.remote_bda, this->remote_bda, 6) != 0) {
-        return;
-      }
-      ESP_LOGV(TAG, "[%s] ESP_GATTC_DISCONNECT_EVT, reason %d", this->address_str().c_str(), param->disconnect.reason);
-      for (auto &svc : this->services_)
-        delete svc;  // NOLINT(cppcoreguidelines-owning-memory)
-      this->services_.clear();
-      this->set_states_(espbt::ClientState::IDLE);
-      break;
-    }
-    case ESP_GATTC_SEARCH_RES_EVT: {
-      BLEService *ble_service = new BLEService();  // NOLINT(cppcoreguidelines-owning-memory)
-      ble_service->uuid = espbt::ESPBTUUID::from_uuid(param->search_res.srvc_id.uuid);
-      ble_service->start_handle = param->search_res.start_handle;
-      ble_service->end_handle = param->search_res.end_handle;
-      ble_service->client = this;
-      this->services_.push_back(ble_service);
-      break;
-    }
-    case ESP_GATTC_SEARCH_CMPL_EVT: {
-      ESP_LOGV(TAG, "[%s] ESP_GATTC_SEARCH_CMPL_EVT", this->address_str().c_str());
-      for (auto &svc : this->services_) {
-        ESP_LOGI(TAG, "Service UUID: %s", svc->uuid.to_string().c_str());
-        ESP_LOGI(TAG, "  start_handle: 0x%x  end_handle: 0x%x", svc->start_handle, svc->end_handle);
-        svc->parse_characteristics();
-      }
-      this->set_states_(espbt::ClientState::CONNECTED);
-      this->set_state(espbt::ClientState::ESTABLISHED);
-      break;
-    }
-    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
-      auto *descr = this->get_config_descriptor(param->reg_for_notify.handle);
-      if (descr == nullptr) {
-        ESP_LOGW(TAG, "No descriptor found for notify of handle 0x%x", param->reg_for_notify.handle);
-        break;
-      }
-      if (descr->uuid.get_uuid().len != ESP_UUID_LEN_16 ||
-          descr->uuid.get_uuid().uuid.uuid16 != ESP_GATT_UUID_CHAR_CLIENT_CONFIG) {
-        ESP_LOGW(TAG, "Handle 0x%x (uuid %s) is not a client config char uuid", param->reg_for_notify.handle,
-                 descr->uuid.to_string().c_str());
-        break;
-      }
-      uint16_t notify_en = 1;
-      auto status =
-          esp_ble_gattc_write_char_descr(this->gattc_if, this->conn_id, descr->handle, sizeof(notify_en),
-                                         (uint8_t *) &notify_en, ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
-      if (status) {
-        ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
-      }
-      break;
-    }
+  if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
+    return false;
 
-    default:
-      break;
-  }
   for (auto *node : this->nodes_)
     node->gattc_event_handler(event, esp_gattc_if, param);
 
@@ -210,239 +63,30 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
       delete svc;  // NOLINT(cppcoreguidelines-owning-memory)
     this->services_.clear();
   }
+  return true;
 }
 
 void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
-  switch (event) {
-    // This event is sent by the server when it requests security
-    case ESP_GAP_BLE_SEC_REQ_EVT:
-      ESP_LOGV(TAG, "ESP_GAP_BLE_SEC_REQ_EVT %x", event);
-      esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true);
-      break;
-    // This event is sent once authentication has completed
-    case ESP_GAP_BLE_AUTH_CMPL_EVT:
-      esp_bd_addr_t bd_addr;
-      memcpy(bd_addr, param->ble_security.auth_cmpl.bd_addr, sizeof(esp_bd_addr_t));
-      ESP_LOGI(TAG, "auth complete. remote BD_ADDR: %s", format_hex(bd_addr, 6).c_str());
-      if (!param->ble_security.auth_cmpl.success) {
-        ESP_LOGE(TAG, "auth fail reason = 0x%x", param->ble_security.auth_cmpl.fail_reason);
-      } else {
-        ESP_LOGV(TAG, "auth success. address type = %d auth mode = %d", param->ble_security.auth_cmpl.addr_type,
-                 param->ble_security.auth_cmpl.auth_mode);
-      }
-      break;
-    // There are other events we'll want to implement at some point to support things like pass key
-    // https://github.com/espressif/esp-idf/blob/cba69dd088344ed9d26739f04736ae7a37541b3a/examples/bluetooth/bluedroid/ble/gatt_security_client/tutorial/Gatt_Security_Client_Example_Walkthrough.md
-    default:
-      break;
+  BLEClientBase::gap_event_handler(event, param);
+
+  for (auto *node : this->nodes_)
+    node->gap_event_handler(event, param);
+}
+
+void BLEClient::set_state(espbt::ClientState state) {
+  BLEClientBase::set_state(state);
+  for (auto &node : nodes_)
+    node->node_state = state;
+}
+
+bool BLEClient::all_nodes_established_() {
+  if (this->state() != espbt::ClientState::ESTABLISHED)
+    return false;
+  for (auto &node : nodes_) {
+    if (node->node_state != espbt::ClientState::ESTABLISHED)
+      return false;
   }
-}
-
-// Parse GATT values into a float for a sensor.
-// Ref: https://www.bluetooth.com/specifications/assigned-numbers/format-types/
-float BLEClient::parse_char_value(uint8_t *value, uint16_t length) {
-  // A length of one means a single octet value.
-  if (length == 0)
-    return 0;
-  if (length == 1)
-    return (float) ((uint8_t) value[0]);
-
-  switch (value[0]) {
-    case 0x1:  // boolean.
-    case 0x2:  // 2bit.
-    case 0x3:  // nibble.
-    case 0x4:  // uint8.
-      return (float) ((uint8_t) value[1]);
-    case 0x5:  // uint12.
-    case 0x6:  // uint16.
-      if (length > 2) {
-        return (float) ((uint16_t)(value[1] << 8) + (uint16_t) value[2]);
-      }
-    case 0x7:  // uint24.
-      if (length > 3) {
-        return (float) ((uint32_t)(value[1] << 16) + (uint32_t)(value[2] << 8) + (uint32_t)(value[3]));
-      }
-    case 0x8:  // uint32.
-      if (length > 4) {
-        return (float) ((uint32_t)(value[1] << 24) + (uint32_t)(value[2] << 16) + (uint32_t)(value[3] << 8) +
-                        (uint32_t)(value[4]));
-      }
-    case 0xC:  // int8.
-      return (float) ((int8_t) value[1]);
-    case 0xD:  // int12.
-    case 0xE:  // int16.
-      if (length > 2) {
-        return (float) ((int16_t)(value[1] << 8) + (int16_t) value[2]);
-      }
-    case 0xF:  // int24.
-      if (length > 3) {
-        return (float) ((int32_t)(value[1] << 16) + (int32_t)(value[2] << 8) + (int32_t)(value[3]));
-      }
-    case 0x10:  // int32.
-      if (length > 4) {
-        return (float) ((int32_t)(value[1] << 24) + (int32_t)(value[2] << 16) + (int32_t)(value[3] << 8) +
-                        (int32_t)(value[4]));
-      }
-  }
-  ESP_LOGW(TAG, "Cannot parse characteristic value of type 0x%x length %d", value[0], length);
-  return NAN;
-}
-
-BLEService *BLEClient::get_service(espbt::ESPBTUUID uuid) {
-  for (auto *svc : this->services_) {
-    if (svc->uuid == uuid)
-      return svc;
-  }
-  return nullptr;
-}
-
-BLEService *BLEClient::get_service(uint16_t uuid) { return this->get_service(espbt::ESPBTUUID::from_uint16(uuid)); }
-
-BLECharacteristic *BLEClient::get_characteristic(espbt::ESPBTUUID service, espbt::ESPBTUUID chr) {
-  auto *svc = this->get_service(service);
-  if (svc == nullptr)
-    return nullptr;
-  return svc->get_characteristic(chr);
-}
-
-BLECharacteristic *BLEClient::get_characteristic(uint16_t service, uint16_t chr) {
-  return this->get_characteristic(espbt::ESPBTUUID::from_uint16(service), espbt::ESPBTUUID::from_uint16(chr));
-}
-
-BLEDescriptor *BLEClient::get_config_descriptor(uint16_t handle) {
-  for (auto &svc : this->services_) {
-    for (auto &chr : svc->characteristics) {
-      if (chr->handle == handle) {
-        for (auto &desc : chr->descriptors) {
-          if (desc->uuid == espbt::ESPBTUUID::from_uint16(0x2902))
-            return desc;
-        }
-      }
-    }
-  }
-  return nullptr;
-}
-
-BLECharacteristic *BLEService::get_characteristic(espbt::ESPBTUUID uuid) {
-  for (auto &chr : this->characteristics) {
-    if (chr->uuid == uuid)
-      return chr;
-  }
-  return nullptr;
-}
-
-BLECharacteristic *BLEService::get_characteristic(uint16_t uuid) {
-  return this->get_characteristic(espbt::ESPBTUUID::from_uint16(uuid));
-}
-
-BLEDescriptor *BLEClient::get_descriptor(espbt::ESPBTUUID service, espbt::ESPBTUUID chr, espbt::ESPBTUUID descr) {
-  auto *svc = this->get_service(service);
-  if (svc == nullptr)
-    return nullptr;
-  auto *ch = svc->get_characteristic(chr);
-  if (ch == nullptr)
-    return nullptr;
-  return ch->get_descriptor(descr);
-}
-
-BLEDescriptor *BLEClient::get_descriptor(uint16_t service, uint16_t chr, uint16_t descr) {
-  return this->get_descriptor(espbt::ESPBTUUID::from_uint16(service), espbt::ESPBTUUID::from_uint16(chr),
-                              espbt::ESPBTUUID::from_uint16(descr));
-}
-
-BLEService::~BLEService() {
-  for (auto &chr : this->characteristics)
-    delete chr;  // NOLINT(cppcoreguidelines-owning-memory)
-}
-
-void BLEService::parse_characteristics() {
-  uint16_t offset = 0;
-  esp_gattc_char_elem_t result;
-
-  while (true) {
-    uint16_t count = 1;
-    esp_gatt_status_t status = esp_ble_gattc_get_all_char(
-        this->client->gattc_if, this->client->conn_id, this->start_handle, this->end_handle, &result, &count, offset);
-    if (status == ESP_GATT_INVALID_OFFSET || status == ESP_GATT_NOT_FOUND) {
-      break;
-    }
-    if (status != ESP_GATT_OK) {
-      ESP_LOGW(TAG, "esp_ble_gattc_get_all_char error, status=%d", status);
-      break;
-    }
-    if (count == 0) {
-      break;
-    }
-
-    BLECharacteristic *characteristic = new BLECharacteristic();  // NOLINT(cppcoreguidelines-owning-memory)
-    characteristic->uuid = espbt::ESPBTUUID::from_uuid(result.uuid);
-    characteristic->properties = result.properties;
-    characteristic->handle = result.char_handle;
-    characteristic->service = this;
-    this->characteristics.push_back(characteristic);
-    ESP_LOGI(TAG, " characteristic %s, handle 0x%x, properties 0x%x", characteristic->uuid.to_string().c_str(),
-             characteristic->handle, characteristic->properties);
-    characteristic->parse_descriptors();
-    offset++;
-  }
-}
-
-BLECharacteristic::~BLECharacteristic() {
-  for (auto &desc : this->descriptors)
-    delete desc;  // NOLINT(cppcoreguidelines-owning-memory)
-}
-
-void BLECharacteristic::parse_descriptors() {
-  uint16_t offset = 0;
-  esp_gattc_descr_elem_t result;
-
-  while (true) {
-    uint16_t count = 1;
-    esp_gatt_status_t status = esp_ble_gattc_get_all_descr(
-        this->service->client->gattc_if, this->service->client->conn_id, this->handle, &result, &count, offset);
-    if (status == ESP_GATT_INVALID_OFFSET || status == ESP_GATT_NOT_FOUND) {
-      break;
-    }
-    if (status != ESP_GATT_OK) {
-      ESP_LOGW(TAG, "esp_ble_gattc_get_all_descr error, status=%d", status);
-      break;
-    }
-    if (count == 0) {
-      break;
-    }
-
-    BLEDescriptor *desc = new BLEDescriptor();  // NOLINT(cppcoreguidelines-owning-memory)
-    desc->uuid = espbt::ESPBTUUID::from_uuid(result.uuid);
-    desc->handle = result.handle;
-    desc->characteristic = this;
-    this->descriptors.push_back(desc);
-    ESP_LOGV(TAG, "   descriptor %s, handle 0x%x", desc->uuid.to_string().c_str(), desc->handle);
-    offset++;
-  }
-}
-
-BLEDescriptor *BLECharacteristic::get_descriptor(espbt::ESPBTUUID uuid) {
-  for (auto &desc : this->descriptors) {
-    if (desc->uuid == uuid)
-      return desc;
-  }
-  return nullptr;
-}
-BLEDescriptor *BLECharacteristic::get_descriptor(uint16_t uuid) {
-  return this->get_descriptor(espbt::ESPBTUUID::from_uint16(uuid));
-}
-
-void BLECharacteristic::write_value(uint8_t *new_val, int16_t new_val_size, esp_gatt_write_type_t write_type) {
-  auto *client = this->service->client;
-  auto status = esp_ble_gattc_write_char(client->gattc_if, client->conn_id, this->handle, new_val_size, new_val,
-                                         write_type, ESP_GATT_AUTH_REQ_NONE);
-  if (status) {
-    ESP_LOGW(TAG, "Error sending write value to BLE gattc server, status=%d", status);
-  }
-}
-
-void BLECharacteristic::write_value(uint8_t *new_val, int16_t new_val_size) {
-  write_value(new_val, new_val_size, ESP_GATT_WRITE_TYPE_NO_RSP);
+  return true;
 }
 
 }  // namespace ble_client

esphome/components/ble_client/ble_client.h

@@ -1,32 +1,35 @@
 #pragma once
 
+#include "esphome/components/esp32_ble_client/ble_client_base.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
-#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 
 #ifdef USE_ESP32
 
-#include <string>
-#include <array>
-#include <esp_gap_ble_api.h>
-#include <esp_gattc_api.h>
 #include <esp_bt_defs.h>
+#include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
+#include <esp_gattc_api.h>
+#include <array>
+#include <string>
+#include <vector>
 
 namespace esphome {
 namespace ble_client {
 
 namespace espbt = esphome::esp32_ble_tracker;
 
+using namespace esp32_ble_client;
+
 class BLEClient;
-class BLEService;
-class BLECharacteristic;
 
 class BLEClientNode {
  public:
   virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) = 0;
-  virtual void loop(){};
+  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
+  virtual void loop() {}
   void set_address(uint64_t address) { address_ = address; }
   espbt::ESPBTClient *client;
   // This should be transitioned to Established once the node no longer needs
@@ -42,57 +45,17 @@ class BLEClientNode {
   uint64_t address_;
 };
 
-class BLEDescriptor {
- public:
-  espbt::ESPBTUUID uuid;
-  uint16_t handle;
-
-  BLECharacteristic *characteristic;
-};
-
-class BLECharacteristic {
- public:
-  ~BLECharacteristic();
-  espbt::ESPBTUUID uuid;
-  uint16_t handle;
-  esp_gatt_char_prop_t properties;
-  std::vector<BLEDescriptor *> descriptors;
-  void parse_descriptors();
-  BLEDescriptor *get_descriptor(espbt::ESPBTUUID uuid);
-  BLEDescriptor *get_descriptor(uint16_t uuid);
-  void write_value(uint8_t *new_val, int16_t new_val_size);
-  void write_value(uint8_t *new_val, int16_t new_val_size, esp_gatt_write_type_t write_type);
-  BLEService *service;
-};
-
-class BLEService {
- public:
-  ~BLEService();
-  espbt::ESPBTUUID uuid;
-  uint16_t start_handle;
-  uint16_t end_handle;
-  std::vector<BLECharacteristic *> characteristics;
-  BLEClient *client;
-  void parse_characteristics();
-  BLECharacteristic *get_characteristic(espbt::ESPBTUUID uuid);
-  BLECharacteristic *get_characteristic(uint16_t uuid);
-};
-
-class BLEClient : public espbt::ESPBTClient, public Component {
+class BLEClient : public BLEClientBase {
  public:
   void setup() override;
   void dump_config() override;
   void loop() override;
-  float get_setup_priority() const override;
 
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+  bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;
+
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
   bool parse_device(const espbt::ESPBTDevice &device) override;
-  void on_scan_end() override {}
-  void connect() override;
-
-  void set_address(uint64_t address) { this->address = address; }
 
   void set_enabled(bool enabled);
 
@@ -102,43 +65,14 @@ class BLEClient : public espbt::ESPBTClient, public Component {
     this->nodes_.push_back(node);
   }
 
-  BLEService *get_service(espbt::ESPBTUUID uuid);
-  BLEService *get_service(uint16_t uuid);
-  BLECharacteristic *get_characteristic(espbt::ESPBTUUID service, espbt::ESPBTUUID chr);
-  BLECharacteristic *get_characteristic(uint16_t service, uint16_t chr);
-  BLEDescriptor *get_descriptor(espbt::ESPBTUUID service, espbt::ESPBTUUID chr, espbt::ESPBTUUID descr);
-  BLEDescriptor *get_descriptor(uint16_t service, uint16_t chr, uint16_t descr);
-  // Get the configuration descriptor for the given characteristic handle.
-  BLEDescriptor *get_config_descriptor(uint16_t handle);
-
-  float parse_char_value(uint8_t *value, uint16_t length);
-
-  int gattc_if;
-  esp_bd_addr_t remote_bda;
-  esp_ble_addr_type_t remote_addr_type;
-  uint16_t conn_id;
-  uint64_t address;
   bool enabled;
-  std::string address_str() const;
+
+  void set_state(espbt::ClientState state) override;
 
  protected:
-  void set_states_(espbt::ClientState st) {
-    this->set_state(st);
-    for (auto &node : nodes_)
-      node->node_state = st;
-  }
-  bool all_nodes_established_() {
-    if (this->state() != espbt::ClientState::ESTABLISHED)
-      return false;
-    for (auto &node : nodes_) {
-      if (node->node_state != espbt::ClientState::ESTABLISHED)
-        return false;
-    }
-    return true;
-  }
+  bool all_nodes_established_();
 
   std::vector<BLEClientNode *> nodes_;
-  std::vector<BLEService *> services_;
 };
 
 }  // namespace ble_client

esphome/components/ble_client/sensor/__init__.py

@@ -5,7 +5,11 @@ from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
     CONF_LAMBDA,
     CONF_TRIGGER_ID,
+    CONF_TYPE,
     CONF_SERVICE_UUID,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_DECIBEL_MILLIWATT,
 )
 from esphome import automation
 from .. import ble_client_ns
@@ -16,6 +20,8 @@ CONF_DESCRIPTOR_UUID = "descriptor_uuid"
 
 CONF_NOTIFY = "notify"
 CONF_ON_NOTIFY = "on_notify"
+TYPE_CHARACTERISTIC = "characteristic"
+TYPE_RSSI = "rssi"
 
 adv_data_t = cg.std_vector.template(cg.uint8)
 adv_data_t_const_ref = adv_data_t.operator("ref").operator("const")
@@ -27,33 +33,67 @@ BLESensorNotifyTrigger = ble_client_ns.class_(
     "BLESensorNotifyTrigger", automation.Trigger.template(cg.float_)
 )
 
-CONFIG_SCHEMA = cv.All(
-    sensor.sensor_schema(
-        BLESensor,
-        accuracy_decimals=0,
-    )
-    .extend(
-        {
-            cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
-            cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
-            cv.Optional(CONF_DESCRIPTOR_UUID): esp32_ble_tracker.bt_uuid,
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
-            cv.Optional(CONF_NOTIFY, default=False): cv.boolean,
-            cv.Optional(CONF_ON_NOTIFY): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLESensorNotifyTrigger
-                    ),
-                }
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(ble_client.BLE_CLIENT_SCHEMA)
+BLEClientRssiSensor = ble_client_ns.class_(
+    "BLEClientRSSISensor", sensor.Sensor, cg.PollingComponent, ble_client.BLEClientNode
 )
 
 
-async def to_code(config):
+def checkType(value):
+    if CONF_TYPE not in value and CONF_SERVICE_UUID in value:
+        raise cv.Invalid(
+            "Looks like you're trying to create a ble characteristic sensor. Please add `type: characteristic` to your sensor config."
+        )
+    return value
+
+
+CONFIG_SCHEMA = cv.All(
+    checkType,
+    cv.typed_schema(
+        {
+            TYPE_CHARACTERISTIC: sensor.sensor_schema(
+                BLESensor,
+                accuracy_decimals=0,
+            )
+            .extend(cv.polling_component_schema("60s"))
+            .extend(ble_client.BLE_CLIENT_SCHEMA)
+            .extend(
+                {
+                    cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+                    cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
+                    cv.Optional(CONF_DESCRIPTOR_UUID): esp32_ble_tracker.bt_uuid,
+                    cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+                    cv.Optional(CONF_NOTIFY, default=False): cv.boolean,
+                    cv.Optional(CONF_ON_NOTIFY): automation.validate_automation(
+                        {
+                            cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                                BLESensorNotifyTrigger
+                            ),
+                        }
+                    ),
+                }
+            ),
+            TYPE_RSSI: sensor.sensor_schema(
+                BLEClientRssiSensor,
+                accuracy_decimals=0,
+                unit_of_measurement=UNIT_DECIBEL_MILLIWATT,
+                device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                state_class=STATE_CLASS_MEASUREMENT,
+            )
+            .extend(cv.polling_component_schema("60s"))
+            .extend(ble_client.BLE_CLIENT_SCHEMA),
+        },
+        lower=True,
+    ),
+)
+
+
+async def rssi_sensor_to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await ble_client.register_ble_node(var, config)
+
+
+async def characteristic_sensor_to_code(config):
     var = await sensor.new_sensor(config)
     if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
         cg.add(
@@ -125,3 +165,10 @@ async def to_code(config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await ble_client.register_ble_node(trigger, config)
         await automation.build_automation(trigger, [(float, "x")], conf)
+
+
+async def to_code(config):
+    if config[CONF_TYPE] == TYPE_RSSI:
+        await rssi_sensor_to_code(config)
+    elif config[CONF_TYPE] == TYPE_CHARACTERISTIC:
+        await characteristic_sensor_to_code(config)

esphome/components/ble_client/sensor/automation.h

@@ -19,7 +19,8 @@ class BLESensorNotifyTrigger : public Trigger<float>, public BLESensor {
         break;
       }
       case ESP_GATTC_NOTIFY_EVT: {
-        if (param->notify.conn_id != this->sensor_->parent()->conn_id || param->notify.handle != this->sensor_->handle)
+        if (param->notify.conn_id != this->sensor_->parent()->get_conn_id() ||
+            param->notify.handle != this->sensor_->handle)
           break;
         this->trigger(this->sensor_->parent()->parse_char_value(param->notify.value, param->notify.value_len));
       }

esphome/components/ble_client/sensor/ble_rssi_sensor.cpp

@@ -0,0 +1,78 @@
+#include "ble_rssi_sensor.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *const TAG = "ble_rssi_sensor";
+
+void BLEClientRSSISensor::loop() {}
+
+void BLEClientRSSISensor::dump_config() {
+  LOG_SENSOR("", "BLE Client RSSI Sensor", this);
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void BLEClientRSSISensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                              esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_OPEN_EVT: {
+      if (param->open.status == ESP_GATT_OK) {
+        ESP_LOGI(TAG, "[%s] Connected successfully!", this->get_name().c_str());
+        break;
+      }
+      break;
+    }
+    case ESP_GATTC_DISCONNECT_EVT: {
+      ESP_LOGW(TAG, "[%s] Disconnected!", this->get_name().c_str());
+      this->status_set_warning();
+      this->publish_state(NAN);
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT:
+      this->node_state = espbt::ClientState::ESTABLISHED;
+      break;
+    default:
+      break;
+  }
+}
+
+void BLEClientRSSISensor::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
+  switch (event) {
+    // server response on RSSI request:
+    case ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT:
+      if (param->read_rssi_cmpl.status == ESP_BT_STATUS_SUCCESS) {
+        int8_t rssi = param->read_rssi_cmpl.rssi;
+        ESP_LOGI(TAG, "ESP_GAP_BLE_READ_RSSI_COMPLETE_EVT RSSI: %d", rssi);
+        this->publish_state(rssi);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+void BLEClientRSSISensor::update() {
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str());
+    return;
+  }
+
+  ESP_LOGV(TAG, "requesting rssi from %s", this->parent()->address_str().c_str());
+  auto status = esp_ble_gap_read_rssi(this->parent()->get_remote_bda());
+  if (status != ESP_OK) {
+    ESP_LOGW(TAG, "esp_ble_gap_read_rssi error, address=%s, status=%d", this->parent()->address_str().c_str(), status);
+    this->status_set_warning();
+    this->publish_state(NAN);
+  }
+}
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/sensor/ble_rssi_sensor.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/ble_client/ble_client.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/sensor/sensor.h"
+
+#ifdef USE_ESP32
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class BLEClientRSSISensor : public sensor::Sensor, public PollingComponent, public BLEClientNode {
+ public:
+  void loop() override;
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+  void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
+
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -63,8 +63,8 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
         this->handle = descr->handle;
       }
       if (this->notify_) {
-        auto status =
-            esp_ble_gattc_register_for_notify(this->parent()->gattc_if, this->parent()->remote_bda, chr->handle);
+        auto status = esp_ble_gattc_register_for_notify(this->parent()->get_gattc_if(),
+                                                        this->parent()->get_remote_bda(), chr->handle);
         if (status) {
           ESP_LOGW(TAG, "esp_ble_gattc_register_for_notify failed, status=%d", status);
         }
@@ -74,7 +74,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       break;
     }
     case ESP_GATTC_READ_CHAR_EVT: {
-      if (param->read.conn_id != this->parent()->conn_id)
+      if (param->read.conn_id != this->parent()->get_conn_id())
         break;
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "Error reading char at handle %d, status=%d", param->read.handle, param->read.status);
@@ -87,7 +87,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
-      if (param->notify.conn_id != this->parent()->conn_id || param->notify.handle != this->handle)
+      if (param->notify.conn_id != this->parent()->get_conn_id() || param->notify.handle != this->handle)
         break;
       ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(),
                param->notify.handle, param->notify.value[0]);
@@ -122,8 +122,8 @@ void BLESensor::update() {
     return;
   }
 
-  auto status =
-      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle, ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_read_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->handle,
+                                        ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     this->status_set_warning();
     this->publish_state(NAN);

esphome/components/ble_client/sensor/ble_sensor.h

@@ -5,6 +5,8 @@
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/components/sensor/sensor.h"
 
+#include <vector>
+
 #ifdef USE_ESP32
 #include <esp_gattc_api.h>
 

esphome/components/ble_client/text_sensor/automation.h

@@ -19,7 +19,8 @@ class BLETextSensorNotifyTrigger : public Trigger<std::string>, public BLETextSe
         break;
       }
       case ESP_GATTC_NOTIFY_EVT: {
-        if (param->notify.conn_id != this->sensor_->parent()->conn_id || param->notify.handle != this->sensor_->handle)
+        if (param->notify.conn_id != this->sensor_->parent()->get_conn_id() ||
+            param->notify.handle != this->sensor_->handle)
           break;
         this->trigger(this->sensor_->parse_data(param->notify.value, param->notify.value_len));
       }

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -66,8 +66,8 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         this->handle = descr->handle;
       }
       if (this->notify_) {
-        auto status =
-            esp_ble_gattc_register_for_notify(this->parent()->gattc_if, this->parent()->remote_bda, chr->handle);
+        auto status = esp_ble_gattc_register_for_notify(this->parent()->get_gattc_if(),
+                                                        this->parent()->get_remote_bda(), chr->handle);
         if (status) {
           ESP_LOGW(TAG, "esp_ble_gattc_register_for_notify failed, status=%d", status);
         }
@@ -77,7 +77,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       break;
     }
     case ESP_GATTC_READ_CHAR_EVT: {
-      if (param->read.conn_id != this->parent()->conn_id)
+      if (param->read.conn_id != this->parent()->get_conn_id())
         break;
       if (param->read.status != ESP_GATT_OK) {
         ESP_LOGW(TAG, "Error reading char at handle %d, status=%d", param->read.handle, param->read.status);
@@ -90,7 +90,7 @@ void BLETextSensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
-      if (param->notify.conn_id != this->parent()->conn_id || param->notify.handle != this->handle)
+      if (param->notify.conn_id != this->parent()->get_conn_id() || param->notify.handle != this->handle)
         break;
       ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(),
                param->notify.handle, param->notify.value[0]);
@@ -121,8 +121,8 @@ void BLETextSensor::update() {
     return;
   }
 
-  auto status =
-      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle, ESP_GATT_AUTH_REQ_NONE);
+  auto status = esp_ble_gattc_read_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->handle,
+                                        ESP_GATT_AUTH_REQ_NONE);
   if (status) {
     this->status_set_warning();
     this->publish_state(EMPTY);

esphome/components/ble_presence/ble_presence_device.h

@@ -58,7 +58,7 @@ class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
       case MATCH_BY_SERVICE_UUID:
         for (auto uuid : device.get_service_uuids()) {
           if (this->uuid_ == uuid) {
-            this->publish_state(device.get_rssi());
+            this->publish_state(true);
             this->found_ = true;
             return true;
           }
@@ -83,7 +83,7 @@ class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
           return false;
         }
 
-        this->publish_state(device.get_rssi());
+        this->publish_state(true);
         this->found_ = true;
         return true;
     }

esphome/components/ble_rssi/sensor.py

@@ -9,7 +9,7 @@ from esphome.const import (
     CONF_MAC_ADDRESS,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     STATE_CLASS_MEASUREMENT,
-    UNIT_DECIBEL,
+    UNIT_DECIBEL_MILLIWATT,
 )
 
 DEPENDENCIES = ["esp32_ble_tracker"]
@@ -31,7 +31,7 @@ def _validate(config):
 CONFIG_SCHEMA = cv.All(
     sensor.sensor_schema(
         BLERSSISensor,
-        unit_of_measurement=UNIT_DECIBEL,
+        unit_of_measurement=UNIT_DECIBEL_MILLIWATT,
         accuracy_decimals=0,
         device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
         state_class=STATE_CLASS_MEASUREMENT,

esphome/components/bluetooth_proxy/__init__.py

@@ -1,27 +1,83 @@
-from esphome.components import esp32_ble_tracker
+from esphome.components import esp32_ble_tracker, esp32_ble_client
 import esphome.config_validation as cv
 import esphome.codegen as cg
-from esphome.const import CONF_ID
+from esphome.const import CONF_ACTIVE, CONF_ID
+from esphome.components.esp32 import add_idf_sdkconfig_option
 
-DEPENDENCIES = ["esp32", "esp32_ble_tracker"]
+AUTO_LOAD = ["esp32_ble_client", "esp32_ble_tracker"]
+DEPENDENCIES = ["api", "esp32"]
 CODEOWNERS = ["@jesserockz"]
 
+CONF_CACHE_SERVICES = "cache_services"
+CONF_CONNECTIONS = "connections"
+MAX_CONNECTIONS = 3
 
 bluetooth_proxy_ns = cg.esphome_ns.namespace("bluetooth_proxy")
 
-BluetoothProxy = bluetooth_proxy_ns.class_("BluetoothProxy", cg.Component)
+BluetoothProxy = bluetooth_proxy_ns.class_(
+    "BluetoothProxy", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
+)
+BluetoothConnection = bluetooth_proxy_ns.class_(
+    "BluetoothConnection", esp32_ble_client.BLEClientBase
+)
 
-CONFIG_SCHEMA = cv.Schema(
+CONNECTION_SCHEMA = esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA.extend(
     {
-        cv.GenerateID(): cv.declare_id(BluetoothProxy),
+        cv.GenerateID(): cv.declare_id(BluetoothConnection),
     }
-).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+).extend(cv.COMPONENT_SCHEMA)
+
+
+def validate_connections(config):
+    if CONF_CONNECTIONS in config:
+        if not config[CONF_ACTIVE]:
+            raise cv.Invalid(
+                "Connections can only be used if the proxy is set to active"
+            )
+    else:
+        if config[CONF_ACTIVE]:
+            conf = config.copy()
+            conf[CONF_CONNECTIONS] = [
+                CONNECTION_SCHEMA({}) for _ in range(MAX_CONNECTIONS)
+            ]
+            return conf
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BluetoothProxy),
+            cv.Optional(CONF_ACTIVE, default=False): cv.boolean,
+            cv.SplitDefault(CONF_CACHE_SERVICES, esp32_idf=True): cv.All(
+                cv.only_with_esp_idf, cv.boolean
+            ),
+            cv.Optional(CONF_CONNECTIONS): cv.All(
+                cv.ensure_list(CONNECTION_SCHEMA),
+                cv.Length(min=1, max=MAX_CONNECTIONS),
+            ),
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    validate_connections,
+)
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    cg.add(var.set_active(config[CONF_ACTIVE]))
     await esp32_ble_tracker.register_ble_device(var, config)
 
+    for connection_conf in config.get(CONF_CONNECTIONS, []):
+        connection_var = cg.new_Pvariable(connection_conf[CONF_ID])
+        await cg.register_component(connection_var, connection_conf)
+        cg.add(var.register_connection(connection_var))
+        await esp32_ble_tracker.register_client(connection_var, connection_conf)
+
+    if config.get(CONF_CACHE_SERVICES):
+        add_idf_sdkconfig_option("CONFIG_BT_GATTC_CACHE_NVS_FLASH", True)
+
     cg.add_define("USE_BLUETOOTH_PROXY")

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -0,0 +1,270 @@
+#include "bluetooth_connection.h"
+
+#include "esphome/components/api/api_server.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+
+#include "bluetooth_proxy.h"
+
+namespace esphome {
+namespace bluetooth_proxy {
+
+static const char *const TAG = "bluetooth_proxy.connection";
+
+bool BluetoothConnection::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                              esp_ble_gattc_cb_param_t *param) {
+  if (!BLEClientBase::gattc_event_handler(event, gattc_if, param))
+    return false;
+
+  switch (event) {
+    case ESP_GATTC_DISCONNECT_EVT: {
+      api::global_api_server->send_bluetooth_device_connection(this->address_, false, 0, param->disconnect.reason);
+      this->set_address(0);
+      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
+                                                              this->proxy_->get_bluetooth_connections_limit());
+      break;
+    }
+    case ESP_GATTC_OPEN_EVT: {
+      if (param->open.conn_id != this->conn_id_)
+        break;
+      if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
+        api::global_api_server->send_bluetooth_device_connection(this->address_, false, 0, param->open.status);
+        this->set_address(0);
+        api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
+                                                                this->proxy_->get_bluetooth_connections_limit());
+      } else if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
+        api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
+        api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
+                                                                this->proxy_->get_bluetooth_connections_limit());
+      }
+      this->seen_mtu_or_services_ = false;
+      break;
+    }
+    case ESP_GATTC_CFG_MTU_EVT: {
+      if (param->cfg_mtu.conn_id != this->conn_id_)
+        break;
+      if (!this->seen_mtu_or_services_) {
+        // We don't know if we will get the MTU or the services first, so
+        // only send the device connection true if we have already received
+        // the services.
+        this->seen_mtu_or_services_ = true;
+        break;
+      }
+      api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
+      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
+                                                              this->proxy_->get_bluetooth_connections_limit());
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      if (param->search_cmpl.conn_id != this->conn_id_)
+        break;
+      if (!this->seen_mtu_or_services_) {
+        // We don't know if we will get the MTU or the services first, so
+        // only send the device connection true if we have already received
+        // the mtu.
+        this->seen_mtu_or_services_ = true;
+        break;
+      }
+      api::global_api_server->send_bluetooth_device_connection(this->address_, true, this->mtu_);
+      api::global_api_server->send_bluetooth_connections_free(this->proxy_->get_bluetooth_connections_free(),
+                                                              this->proxy_->get_bluetooth_connections_limit());
+      break;
+    }
+    case ESP_GATTC_READ_DESCR_EVT:
+    case ESP_GATTC_READ_CHAR_EVT: {
+      if (param->read.conn_id != this->conn_id_)
+        break;
+      if (param->read.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "[%d] [%s] Error reading char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
+                 this->address_str_.c_str(), param->read.handle, param->read.status);
+        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->read.handle, param->read.status);
+        break;
+      }
+      api::BluetoothGATTReadResponse resp;
+      resp.address = this->address_;
+      resp.handle = param->read.handle;
+      resp.data.reserve(param->read.value_len);
+      for (uint16_t i = 0; i < param->read.value_len; i++) {
+        resp.data.push_back(param->read.value[i]);
+      }
+      api::global_api_server->send_bluetooth_gatt_read_response(resp);
+      break;
+    }
+    case ESP_GATTC_WRITE_CHAR_EVT:
+    case ESP_GATTC_WRITE_DESCR_EVT: {
+      if (param->write.conn_id != this->conn_id_)
+        break;
+      if (param->write.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "[%d] [%s] Error writing char/descriptor at handle 0x%2X, status=%d", this->connection_index_,
+                 this->address_str_.c_str(), param->write.handle, param->write.status);
+        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->write.handle, param->write.status);
+        break;
+      }
+      api::BluetoothGATTWriteResponse resp;
+      resp.address = this->address_;
+      resp.handle = param->write.handle;
+      api::global_api_server->send_bluetooth_gatt_write_response(resp);
+      break;
+    }
+    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT: {
+      if (param->unreg_for_notify.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "[%d] [%s] Error unregistering notifications for handle 0x%2X, status=%d",
+                 this->connection_index_, this->address_str_.c_str(), param->unreg_for_notify.handle,
+                 param->unreg_for_notify.status);
+        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->unreg_for_notify.handle,
+                                                          param->unreg_for_notify.status);
+        break;
+      }
+      api::BluetoothGATTNotifyResponse resp;
+      resp.address = this->address_;
+      resp.handle = param->unreg_for_notify.handle;
+      api::global_api_server->send_bluetooth_gatt_notify_response(resp);
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      if (param->reg_for_notify.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "[%d] [%s] Error registering notifications for handle 0x%2X, status=%d", this->connection_index_,
+                 this->address_str_.c_str(), param->reg_for_notify.handle, param->reg_for_notify.status);
+        api::global_api_server->send_bluetooth_gatt_error(this->address_, param->reg_for_notify.handle,
+                                                          param->reg_for_notify.status);
+        break;
+      }
+      api::BluetoothGATTNotifyResponse resp;
+      resp.address = this->address_;
+      resp.handle = param->reg_for_notify.handle;
+      api::global_api_server->send_bluetooth_gatt_notify_response(resp);
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.conn_id != this->conn_id_)
+        break;
+      ESP_LOGV(TAG, "[%d] [%s] ESP_GATTC_NOTIFY_EVT: handle=0x%2X", this->connection_index_, this->address_str_.c_str(),
+               param->notify.handle);
+      api::BluetoothGATTNotifyDataResponse resp;
+      resp.address = this->address_;
+      resp.handle = param->notify.handle;
+      resp.data.reserve(param->notify.value_len);
+      for (uint16_t i = 0; i < param->notify.value_len; i++) {
+        resp.data.push_back(param->notify.value[i]);
+      }
+      api::global_api_server->send_bluetooth_gatt_notify_data_response(resp);
+      break;
+    }
+    default:
+      break;
+  }
+  return true;
+}
+
+esp_err_t BluetoothConnection::read_characteristic(uint16_t handle) {
+  if (!this->connected()) {
+    ESP_LOGW(TAG, "[%d] [%s] Cannot read GATT characteristic, not connected.", this->connection_index_,
+             this->address_str_.c_str());
+    return ESP_GATT_NOT_CONNECTED;
+  }
+
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
+           handle);
+
+  esp_err_t err = esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
+  if (err != ERR_OK) {
+    ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_read_char error, err=%d", this->connection_index_,
+             this->address_str_.c_str(), err);
+    return err;
+  }
+  return ESP_OK;
+}
+
+esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const std::string &data, bool response) {
+  if (!this->connected()) {
+    ESP_LOGW(TAG, "[%d] [%s] Cannot write GATT characteristic, not connected.", this->connection_index_,
+             this->address_str_.c_str());
+    return ESP_GATT_NOT_CONNECTED;
+  }
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
+           handle);
+
+  esp_err_t err =
+      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, data.size(), (uint8_t *) data.data(),
+                               response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+  if (err != ERR_OK) {
+    ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_write_char error, err=%d", this->connection_index_,
+             this->address_str_.c_str(), err);
+    return err;
+  }
+  return ESP_OK;
+}
+
+esp_err_t BluetoothConnection::read_descriptor(uint16_t handle) {
+  if (!this->connected()) {
+    ESP_LOGW(TAG, "[%d] [%s] Cannot read GATT descriptor, not connected.", this->connection_index_,
+             this->address_str_.c_str());
+    return ESP_GATT_NOT_CONNECTED;
+  }
+  ESP_LOGV(TAG, "[%d] [%s] Reading GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
+           handle);
+
+  esp_err_t err = esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
+  if (err != ERR_OK) {
+    ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_read_char_descr error, err=%d", this->connection_index_,
+             this->address_str_.c_str(), err);
+    return err;
+  }
+  return ESP_OK;
+}
+
+esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const std::string &data, bool response) {
+  if (!this->connected()) {
+    ESP_LOGW(TAG, "[%d] [%s] Cannot write GATT descriptor, not connected.", this->connection_index_,
+             this->address_str_.c_str());
+    return ESP_GATT_NOT_CONNECTED;
+  }
+  ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
+           handle);
+
+  esp_err_t err = esp_ble_gattc_write_char_descr(
+      this->gattc_if_, this->conn_id_, handle, data.size(), (uint8_t *) data.data(),
+      response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+  if (err != ERR_OK) {
+    ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_write_char_descr error, err=%d", this->connection_index_,
+             this->address_str_.c_str(), err);
+    return err;
+  }
+  return ESP_OK;
+}
+
+esp_err_t BluetoothConnection::notify_characteristic(uint16_t handle, bool enable) {
+  if (!this->connected()) {
+    ESP_LOGW(TAG, "[%d] [%s] Cannot notify GATT characteristic, not connected.", this->connection_index_,
+             this->address_str_.c_str());
+    return ESP_GATT_NOT_CONNECTED;
+  }
+
+  if (enable) {
+    ESP_LOGV(TAG, "[%d] [%s] Registering for GATT characteristic notifications handle %d", this->connection_index_,
+             this->address_str_.c_str(), handle);
+    esp_err_t err = esp_ble_gattc_register_for_notify(this->gattc_if_, this->remote_bda_, handle);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_register_for_notify failed, err=%d", this->connection_index_,
+               this->address_str_.c_str(), err);
+      return err;
+    }
+  } else {
+    ESP_LOGV(TAG, "[%d] [%s] Unregistering for GATT characteristic notifications handle %d", this->connection_index_,
+             this->address_str_.c_str(), handle);
+    esp_err_t err = esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_unregister_for_notify failed, err=%d", this->connection_index_,
+               this->address_str_.c_str(), err);
+      return err;
+    }
+  }
+  return ESP_OK;
+}
+
+}  // namespace bluetooth_proxy
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/bluetooth_proxy/bluetooth_connection.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include "esphome/components/esp32_ble_client/ble_client_base.h"
+
+namespace esphome {
+namespace bluetooth_proxy {
+
+class BluetoothProxy;
+
+class BluetoothConnection : public esp32_ble_client::BLEClientBase {
+ public:
+  bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
+
+  esp_err_t read_characteristic(uint16_t handle);
+  esp_err_t write_characteristic(uint16_t handle, const std::string &data, bool response);
+  esp_err_t read_descriptor(uint16_t handle);
+  esp_err_t write_descriptor(uint16_t handle, const std::string &data, bool response);
+
+  esp_err_t notify_characteristic(uint16_t handle, bool enable);
+
+ protected:
+  friend class BluetoothProxy;
+  bool seen_mtu_or_services_{false};
+
+  int16_t send_service_{-2};
+  BluetoothProxy *proxy_;
+};
+
+}  // namespace bluetooth_proxy
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -1,31 +1,45 @@
 #include "bluetooth_proxy.h"
 
-#ifdef USE_API
-#include "esphome/components/api/api_pb2.h"
-#include "esphome/components/api/api_server.h"
-#endif  // USE_API
 #include "esphome/core/log.h"
 
 #ifdef USE_ESP32
 
+#include "esphome/components/api/api_server.h"
+
 namespace esphome {
 namespace bluetooth_proxy {
 
 static const char *const TAG = "bluetooth_proxy";
+static const int DONE_SENDING_SERVICES = -2;
+
+std::vector<uint64_t> get_128bit_uuid_vec(esp_bt_uuid_t uuid_source) {
+  esp_bt_uuid_t uuid = espbt::ESPBTUUID::from_uuid(uuid_source).as_128bit().get_uuid();
+  return std::vector<uint64_t>{((uint64_t) uuid.uuid.uuid128[15] << 56) | ((uint64_t) uuid.uuid.uuid128[14] << 48) |
+                                   ((uint64_t) uuid.uuid.uuid128[13] << 40) | ((uint64_t) uuid.uuid.uuid128[12] << 32) |
+                                   ((uint64_t) uuid.uuid.uuid128[11] << 24) | ((uint64_t) uuid.uuid.uuid128[10] << 16) |
+                                   ((uint64_t) uuid.uuid.uuid128[9] << 8) | ((uint64_t) uuid.uuid.uuid128[8]),
+                               ((uint64_t) uuid.uuid.uuid128[7] << 56) | ((uint64_t) uuid.uuid.uuid128[6] << 48) |
+                                   ((uint64_t) uuid.uuid.uuid128[5] << 40) | ((uint64_t) uuid.uuid.uuid128[4] << 32) |
+                                   ((uint64_t) uuid.uuid.uuid128[3] << 24) | ((uint64_t) uuid.uuid.uuid128[2] << 16) |
+                                   ((uint64_t) uuid.uuid.uuid128[1] << 8) | ((uint64_t) uuid.uuid.uuid128[0])};
+}
+
+BluetoothProxy::BluetoothProxy() { global_bluetooth_proxy = this; }
 
 bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  if (!api::global_api_server->is_connected())
+    return false;
   ESP_LOGV(TAG, "Proxying packet from %s - %s. RSSI: %d dB", device.get_name().c_str(), device.address_str().c_str(),
            device.get_rssi());
   this->send_api_packet_(device);
+
   return true;
 }
 
 void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device) {
-#ifndef USE_API
-  return;
-#else
   api::BluetoothLEAdvertisementResponse resp;
   resp.address = device.address_uint64();
+  resp.address_type = device.get_address_type();
   if (!device.get_name().empty())
     resp.name = device.get_name();
   resp.rssi = device.get_rssi();
@@ -35,22 +49,341 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
   for (auto &data : device.get_service_datas()) {
     api::BluetoothServiceData service_data;
     service_data.uuid = data.uuid.to_string();
-    for (auto d : data.data)
-      service_data.data.push_back(d);
-    resp.service_data.push_back(service_data);
+    service_data.data.assign(data.data.begin(), data.data.end());
+    resp.service_data.push_back(std::move(service_data));
   }
   for (auto &data : device.get_manufacturer_datas()) {
     api::BluetoothServiceData manufacturer_data;
     manufacturer_data.uuid = data.uuid.to_string();
-    for (auto d : data.data)
-      manufacturer_data.data.push_back(d);
-    resp.manufacturer_data.push_back(manufacturer_data);
+    manufacturer_data.data.assign(data.data.begin(), data.data.end());
+    resp.manufacturer_data.push_back(std::move(manufacturer_data));
   }
   api::global_api_server->send_bluetooth_le_advertisement(resp);
-#endif
 }
 
-void BluetoothProxy::dump_config() { ESP_LOGCONFIG(TAG, "Bluetooth Proxy:"); }
+void BluetoothProxy::dump_config() {
+  ESP_LOGCONFIG(TAG, "Bluetooth Proxy:");
+  ESP_LOGCONFIG(TAG, "  Active: %s", YESNO(this->active_));
+}
+
+int BluetoothProxy::get_bluetooth_connections_free() {
+  int free = 0;
+  for (auto *connection : this->connections_) {
+    if (connection->address_ == 0) {
+      free++;
+      ESP_LOGV(TAG, "[%d] Free connection", connection->get_connection_index());
+    } else {
+      ESP_LOGV(TAG, "[%d] Used connection by [%s]", connection->get_connection_index(),
+               connection->address_str().c_str());
+    }
+  }
+  return free;
+}
+
+void BluetoothProxy::loop() {
+  if (!api::global_api_server->is_connected()) {
+    for (auto *connection : this->connections_) {
+      if (connection->get_address() != 0) {
+        connection->disconnect();
+      }
+    }
+    return;
+  }
+  for (auto *connection : this->connections_) {
+    if (connection->send_service_ == connection->service_count_) {
+      connection->send_service_ = DONE_SENDING_SERVICES;
+      api::global_api_server->send_bluetooth_gatt_services_done(connection->get_address());
+      if (connection->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
+          connection->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
+        connection->release_services();
+      }
+    } else if (connection->send_service_ >= 0) {
+      esp_gattc_service_elem_t service_result;
+      uint16_t service_count = 1;
+      esp_gatt_status_t service_status =
+          esp_ble_gattc_get_service(connection->get_gattc_if(), connection->get_conn_id(), nullptr, &service_result,
+                                    &service_count, connection->send_service_);
+      connection->send_service_++;
+      if (service_status != ESP_GATT_OK) {
+        ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service error at offset=%d, status=%d",
+                 connection->get_connection_index(), connection->address_str().c_str(), connection->send_service_ - 1,
+                 service_status);
+        continue;
+      }
+      if (service_count == 0) {
+        ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service missing, service_count=%d",
+                 connection->get_connection_index(), connection->address_str().c_str(), service_count);
+        continue;
+      }
+      api::BluetoothGATTGetServicesResponse resp;
+      resp.address = connection->get_address();
+      api::BluetoothGATTService service_resp;
+      service_resp.uuid = get_128bit_uuid_vec(service_result.uuid);
+      service_resp.handle = service_result.start_handle;
+      uint16_t char_offset = 0;
+      esp_gattc_char_elem_t char_result;
+      while (true) {  // characteristics
+        uint16_t char_count = 1;
+        esp_gatt_status_t char_status = esp_ble_gattc_get_all_char(
+            connection->get_gattc_if(), connection->get_conn_id(), service_result.start_handle,
+            service_result.end_handle, &char_result, &char_count, char_offset);
+        if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND) {
+          break;
+        }
+        if (char_status != ESP_GATT_OK) {
+          ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", connection->get_connection_index(),
+                   connection->address_str().c_str(), char_status);
+          break;
+        }
+        if (char_count == 0) {
+          break;
+        }
+        api::BluetoothGATTCharacteristic characteristic_resp;
+        characteristic_resp.uuid = get_128bit_uuid_vec(char_result.uuid);
+        characteristic_resp.handle = char_result.char_handle;
+        characteristic_resp.properties = char_result.properties;
+        char_offset++;
+        uint16_t desc_offset = 0;
+        esp_gattc_descr_elem_t desc_result;
+        while (true) {  // descriptors
+          uint16_t desc_count = 1;
+          esp_gatt_status_t desc_status =
+              esp_ble_gattc_get_all_descr(connection->get_gattc_if(), connection->get_conn_id(),
+                                          char_result.char_handle, &desc_result, &desc_count, desc_offset);
+          if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
+            break;
+          }
+          if (desc_status != ESP_GATT_OK) {
+            ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", connection->get_connection_index(),
+                     connection->address_str().c_str(), desc_status);
+            break;
+          }
+          if (desc_count == 0) {
+            break;
+          }
+          api::BluetoothGATTDescriptor descriptor_resp;
+          descriptor_resp.uuid = get_128bit_uuid_vec(desc_result.uuid);
+          descriptor_resp.handle = desc_result.handle;
+          characteristic_resp.descriptors.push_back(std::move(descriptor_resp));
+          desc_offset++;
+        }
+        service_resp.characteristics.push_back(std::move(characteristic_resp));
+      }
+      resp.services.push_back(std::move(service_resp));
+      api::global_api_server->send_bluetooth_gatt_services(resp);
+    }
+  }
+}
+
+BluetoothConnection *BluetoothProxy::get_connection_(uint64_t address, bool reserve) {
+  for (auto *connection : this->connections_) {
+    if (connection->get_address() == address)
+      return connection;
+  }
+
+  if (!reserve)
+    return nullptr;
+
+  for (auto *connection : this->connections_) {
+    if (connection->get_address() == 0) {
+      connection->send_service_ = DONE_SENDING_SERVICES;
+      connection->set_address(address);
+      // All connections must start at INIT
+      // We only set the state if we allocate the connection
+      // to avoid a race where multiple connection attempts
+      // are made.
+      connection->set_state(espbt::ClientState::INIT);
+      return connection;
+    }
+  }
+
+  return nullptr;
+}
+
+void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest &msg) {
+  switch (msg.request_type) {
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE:
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE:
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT: {
+      auto *connection = this->get_connection_(msg.address, true);
+      if (connection == nullptr) {
+        ESP_LOGW(TAG, "No free connections available");
+        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
+        return;
+      }
+      if (connection->state() == espbt::ClientState::CONNECTED ||
+          connection->state() == espbt::ClientState::ESTABLISHED) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection already established", connection->get_connection_index(),
+                 connection->address_str().c_str());
+        api::global_api_server->send_bluetooth_device_connection(msg.address, true);
+        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
+                                                                this->get_bluetooth_connections_limit());
+        return;
+      } else if (connection->state() == espbt::ClientState::SEARCHING) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, already searching for device",
+                 connection->get_connection_index(), connection->address_str().c_str());
+        return;
+      } else if (connection->state() == espbt::ClientState::DISCOVERED) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, device already discovered",
+                 connection->get_connection_index(), connection->address_str().c_str());
+        return;
+      } else if (connection->state() == espbt::ClientState::READY_TO_CONNECT) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, waiting in line to connect",
+                 connection->get_connection_index(), connection->address_str().c_str());
+        return;
+      } else if (connection->state() == espbt::ClientState::CONNECTING) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, already connecting", connection->get_connection_index(),
+                 connection->address_str().c_str());
+        return;
+      } else if (connection->state() == espbt::ClientState::DISCONNECTING) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection request ignored, device is disconnecting",
+                 connection->get_connection_index(), connection->address_str().c_str());
+        return;
+      } else if (connection->state() != espbt::ClientState::INIT) {
+        ESP_LOGW(TAG, "[%d] [%s] Connection already in progress", connection->get_connection_index(),
+                 connection->address_str().c_str());
+        return;
+      }
+      if (msg.request_type == api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE) {
+        connection->set_connection_type(espbt::ConnectionType::V3_WITH_CACHE);
+        ESP_LOGI(TAG, "[%d] [%s] Connecting v3 with cache", connection->get_connection_index(),
+                 connection->address_str().c_str());
+      } else if (msg.request_type == api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE) {
+        connection->set_connection_type(espbt::ConnectionType::V3_WITHOUT_CACHE);
+        ESP_LOGI(TAG, "[%d] [%s] Connecting v3 without cache", connection->get_connection_index(),
+                 connection->address_str().c_str());
+      } else {
+        connection->set_connection_type(espbt::ConnectionType::V1);
+        ESP_LOGI(TAG, "[%d] [%s] Connecting v1", connection->get_connection_index(), connection->address_str().c_str());
+      }
+      if (msg.has_address_type) {
+        connection->remote_bda_[0] = (msg.address >> 40) & 0xFF;
+        connection->remote_bda_[1] = (msg.address >> 32) & 0xFF;
+        connection->remote_bda_[2] = (msg.address >> 24) & 0xFF;
+        connection->remote_bda_[3] = (msg.address >> 16) & 0xFF;
+        connection->remote_bda_[4] = (msg.address >> 8) & 0xFF;
+        connection->remote_bda_[5] = (msg.address >> 0) & 0xFF;
+        connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
+        connection->set_state(espbt::ClientState::DISCOVERED);
+      } else {
+        connection->set_state(espbt::ClientState::SEARCHING);
+      }
+      api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
+                                                              this->get_bluetooth_connections_limit());
+      break;
+    }
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_DISCONNECT: {
+      auto *connection = this->get_connection_(msg.address, false);
+      if (connection == nullptr) {
+        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
+        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
+                                                                this->get_bluetooth_connections_limit());
+        return;
+      }
+      if (connection->state() != espbt::ClientState::IDLE) {
+        connection->disconnect();
+      } else {
+        connection->set_address(0);
+        api::global_api_server->send_bluetooth_device_connection(msg.address, false);
+        api::global_api_server->send_bluetooth_connections_free(this->get_bluetooth_connections_free(),
+                                                                this->get_bluetooth_connections_limit());
+      }
+      break;
+    }
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_PAIR:
+    case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_UNPAIR:
+      break;
+  }
+}
+
+void BluetoothProxy::bluetooth_gatt_read(const api::BluetoothGATTReadRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr) {
+    ESP_LOGW(TAG, "Cannot read GATT characteristic, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+
+  auto err = connection->read_characteristic(msg.handle);
+  if (err != ESP_OK) {
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+  }
+}
+
+void BluetoothProxy::bluetooth_gatt_write(const api::BluetoothGATTWriteRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr) {
+    ESP_LOGW(TAG, "Cannot write GATT characteristic, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+
+  auto err = connection->write_characteristic(msg.handle, msg.data, msg.response);
+  if (err != ESP_OK) {
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+  }
+}
+
+void BluetoothProxy::bluetooth_gatt_read_descriptor(const api::BluetoothGATTReadDescriptorRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr) {
+    ESP_LOGW(TAG, "Cannot read GATT descriptor, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+
+  auto err = connection->read_descriptor(msg.handle);
+  if (err != ESP_OK) {
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+  }
+}
+
+void BluetoothProxy::bluetooth_gatt_write_descriptor(const api::BluetoothGATTWriteDescriptorRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr) {
+    ESP_LOGW(TAG, "Cannot write GATT descriptor, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+
+  auto err = connection->write_descriptor(msg.handle, msg.data, true);
+  if (err != ESP_OK) {
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+  }
+}
+
+void BluetoothProxy::bluetooth_gatt_send_services(const api::BluetoothGATTGetServicesRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr || !connection->connected()) {
+    ESP_LOGW(TAG, "Cannot get GATT services, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, 0, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+  if (!connection->service_count_) {
+    ESP_LOGW(TAG, "[%d] [%s] No GATT services found", connection->connection_index_, connection->address_str().c_str());
+    api::global_api_server->send_bluetooth_gatt_services_done(msg.address);
+    return;
+  }
+  if (connection->send_service_ ==
+      DONE_SENDING_SERVICES)  // Only start sending services if we're not already sending them
+    connection->send_service_ = 0;
+}
+
+void BluetoothProxy::bluetooth_gatt_notify(const api::BluetoothGATTNotifyRequest &msg) {
+  auto *connection = this->get_connection_(msg.address, false);
+  if (connection == nullptr) {
+    ESP_LOGW(TAG, "Cannot notify GATT characteristic, not connected");
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, ESP_GATT_NOT_CONNECTED);
+    return;
+  }
+
+  auto err = connection->notify_characteristic(msg.handle, msg.enable);
+  if (err != ESP_OK) {
+    api::global_api_server->send_bluetooth_gatt_error(msg.address, msg.handle, err);
+  }
+}
+
+BluetoothProxy *global_bluetooth_proxy = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace bluetooth_proxy
 }  // namespace esphome

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -3,23 +3,62 @@
 #ifdef USE_ESP32
 
 #include <map>
+#include <vector>
 
+#include "esphome/components/api/api_pb2.h"
+#include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+
+#include "bluetooth_connection.h"
 
 namespace esphome {
 namespace bluetooth_proxy {
 
-class BluetoothProxy : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
+static const esp_err_t ESP_GATT_NOT_CONNECTED = -1;
+
+using namespace esp32_ble_client;
+
+class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Component {
  public:
+  BluetoothProxy();
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
   void dump_config() override;
+  void loop() override;
+
+  void register_connection(BluetoothConnection *connection) {
+    this->connections_.push_back(connection);
+    connection->proxy_ = this;
+  }
+
+  void bluetooth_device_request(const api::BluetoothDeviceRequest &msg);
+  void bluetooth_gatt_read(const api::BluetoothGATTReadRequest &msg);
+  void bluetooth_gatt_write(const api::BluetoothGATTWriteRequest &msg);
+  void bluetooth_gatt_read_descriptor(const api::BluetoothGATTReadDescriptorRequest &msg);
+  void bluetooth_gatt_write_descriptor(const api::BluetoothGATTWriteDescriptorRequest &msg);
+  void bluetooth_gatt_send_services(const api::BluetoothGATTGetServicesRequest &msg);
+  void bluetooth_gatt_notify(const api::BluetoothGATTNotifyRequest &msg);
+
+  int get_bluetooth_connections_free();
+  int get_bluetooth_connections_limit() { return this->connections_.size(); }
+
+  void set_active(bool active) { this->active_ = active; }
+  bool has_active() { return this->active_; }
 
  protected:
   void send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device);
+
+  BluetoothConnection *get_connection_(uint64_t address, bool reserve);
+
+  bool active_;
+
+  std::vector<BluetoothConnection *> connections_{};
 };
 
+extern BluetoothProxy *global_bluetooth_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 }  // namespace bluetooth_proxy
 }  // namespace esphome
 

esphome/components/canbus/canbus.h

@@ -4,6 +4,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/optional.h"
 
+#include <vector>
+
 namespace esphome {
 namespace canbus {
 

esphome/components/cap1188/cap1188.h

@@ -6,6 +6,8 @@
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace cap1188 {
 

esphome/components/captive_portal/__init__.py

@@ -22,6 +22,7 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.only_with_arduino,
+    cv.only_on(["esp32", "esp8266"]),
 )
 
 

esphome/components/cd74hc4067/__init__.py

@@ -27,10 +27,10 @@ DEFAULT_DELAY = "2ms"
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(CD74HC4067Component),
-        cv.Required(CONF_PIN_S0): pins.internal_gpio_output_pin_schema,
-        cv.Required(CONF_PIN_S1): pins.internal_gpio_output_pin_schema,
-        cv.Required(CONF_PIN_S2): pins.internal_gpio_output_pin_schema,
-        cv.Required(CONF_PIN_S3): pins.internal_gpio_output_pin_schema,
+        cv.Required(CONF_PIN_S0): pins.gpio_output_pin_schema,
+        cv.Required(CONF_PIN_S1): pins.gpio_output_pin_schema,
+        cv.Required(CONF_PIN_S2): pins.gpio_output_pin_schema,
+        cv.Required(CONF_PIN_S3): pins.gpio_output_pin_schema,
         cv.Optional(
             CONF_DELAY, default=DEFAULT_DELAY
         ): cv.positive_time_period_milliseconds,

esphome/components/cd74hc4067/cd74hc4067.h

@@ -19,22 +19,22 @@ class CD74HC4067Component : public Component {
   void activate_pin(uint8_t pin);
 
   /// set the pin connected to multiplexer control pin 0
-  void set_pin_s0(InternalGPIOPin *pin) { this->pin_s0_ = pin; }
+  void set_pin_s0(GPIOPin *pin) { this->pin_s0_ = pin; }
   /// set the pin connected to multiplexer control pin 1
-  void set_pin_s1(InternalGPIOPin *pin) { this->pin_s1_ = pin; }
+  void set_pin_s1(GPIOPin *pin) { this->pin_s1_ = pin; }
   /// set the pin connected to multiplexer control pin 2
-  void set_pin_s2(InternalGPIOPin *pin) { this->pin_s2_ = pin; }
+  void set_pin_s2(GPIOPin *pin) { this->pin_s2_ = pin; }
   /// set the pin connected to multiplexer control pin 3
-  void set_pin_s3(InternalGPIOPin *pin) { this->pin_s3_ = pin; }
+  void set_pin_s3(GPIOPin *pin) { this->pin_s3_ = pin; }
 
   /// set the delay needed after an input switch
   void set_switch_delay(uint32_t switch_delay) { this->switch_delay_ = switch_delay; }
 
  private:
-  InternalGPIOPin *pin_s0_;
-  InternalGPIOPin *pin_s1_;
-  InternalGPIOPin *pin_s2_;
-  InternalGPIOPin *pin_s3_;
+  GPIOPin *pin_s0_;
+  GPIOPin *pin_s1_;
+  GPIOPin *pin_s2_;
+  GPIOPin *pin_s3_;
   /// the currently active pin
   uint8_t active_pin_;
   uint32_t switch_delay_;

esphome/components/climate/__init__.py

@@ -113,7 +113,9 @@ 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): cv.temperature,
+                cv.Optional(CONF_TEMPERATURE_STEP): cv.float_with_unit(
+                    "visual_temperature", "(°C|° C|°|C|° K|° K|K|°F|° F|F)?"
+                ),
             }
         ),
         cv.Optional(CONF_ACTION_STATE_TOPIC): cv.All(

esphome/components/climate/climate.cpp

@@ -540,12 +540,15 @@ void Climate::dump_traits_(const char *tag) {
   ESP_LOGCONFIG(tag, "      - Min: %.1f", traits.get_visual_min_temperature());
   ESP_LOGCONFIG(tag, "      - Max: %.1f", traits.get_visual_max_temperature());
   ESP_LOGCONFIG(tag, "      - Step: %.1f", traits.get_visual_temperature_step());
-  if (traits.get_supports_current_temperature())
+  if (traits.get_supports_current_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports current temperature");
-  if (traits.get_supports_two_point_target_temperature())
+  }
+  if (traits.get_supports_two_point_target_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");
-  if (traits.get_supports_action())
+  }
+  if (traits.get_supports_action()) {
     ESP_LOGCONFIG(tag, "  [x] Supports action");
+  }
   if (!traits.get_supported_modes().empty()) {
     ESP_LOGCONFIG(tag, "  [x] Supported modes:");
     for (ClimateMode m : traits.get_supported_modes())

esphome/components/current_based/current_based_cover.cpp

@@ -13,6 +13,7 @@ using namespace esphome::cover;
 CoverTraits CurrentBasedCover::get_traits() {
   auto traits = CoverTraits();
   traits.set_supports_position(true);
+  traits.set_supports_toggle(true);
   traits.set_is_assumed_state(false);
   return traits;
 }
@@ -20,6 +21,20 @@ void CurrentBasedCover::control(const CoverCall &call) {
   if (call.get_stop()) {
     this->direction_idle_();
   }
+  if (call.get_toggle().has_value()) {
+    if (this->current_operation != COVER_OPERATION_IDLE) {
+      this->start_direction_(COVER_OPERATION_IDLE);
+      this->publish_state();
+    } else {
+      if (this->position == COVER_CLOSED || this->last_operation_ == COVER_OPERATION_CLOSING) {
+        this->target_position_ = COVER_OPEN;
+        this->start_direction_(COVER_OPERATION_OPENING);
+      } else {
+        this->target_position_ = COVER_CLOSED;
+        this->start_direction_(COVER_OPERATION_CLOSING);
+      }
+    }
+  }
   if (call.get_position().has_value()) {
     auto pos = *call.get_position();
     if (pos == this->position) {
@@ -164,7 +179,7 @@ bool CurrentBasedCover::is_closing_blocked_() const {
   if (this->close_obstacle_current_threshold_ == FLT_MAX) {
     return false;
   }
-  return this->open_sensor_->get_state() > this->open_obstacle_current_threshold_;
+  return this->close_sensor_->get_state() > this->close_obstacle_current_threshold_;
 }
 bool CurrentBasedCover::is_initial_delay_finished_() const {
   return millis() - this->start_dir_time_ > this->start_sensing_delay_;
@@ -202,9 +217,11 @@ void CurrentBasedCover::start_direction_(CoverOperation dir) {
       trig = this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
+      this->last_operation_ = dir;
       trig = this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
+      this->last_operation_ = dir;
       trig = this->close_trigger_;
       break;
     default:

esphome/components/current_based/current_based_cover.h

@@ -89,6 +89,8 @@ class CurrentBasedCover : public cover::Cover, public Component {
   uint32_t start_dir_time_{0};
   uint32_t last_publish_time_{0};
   float target_position_{0};
+
+  cover::CoverOperation last_operation_{cover::COVER_OPERATION_OPENING};
 };
 
 }  // namespace current_based

esphome/components/custom/binary_sensor/custom_binary_sensor.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/climate/custom_climate.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/climate/climate.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/cover/custom_cover.h

@@ -2,6 +2,8 @@
 
 #include "esphome/components/cover/cover.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/light/custom_light_output.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/light/light_output.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/output/custom_output.h

@@ -4,6 +4,8 @@
 #include "esphome/components/output/binary_output.h"
 #include "esphome/components/output/float_output.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/sensor/custom_sensor.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/switch/custom_switch.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/switch/switch.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom/text_sensor/custom_text_sensor.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/components/text_sensor/text_sensor.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom {
 

esphome/components/custom_component/custom_component.h

@@ -3,6 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/application.h"
 
+#include <vector>
+
 namespace esphome {
 namespace custom_component {
 

esphome/components/dac7678/dac7678_output.cpp

@@ -29,8 +29,9 @@ void DAC7678Output::setup() {
     ESP_LOGE(TAG, "Reset failed");
     this->mark_failed();
     return;
-  } else
+  } else {
     ESP_LOGV(TAG, "Reset succeeded");
+  }
 
   delayMicroseconds(1000);
 
@@ -40,16 +41,18 @@ void DAC7678Output::setup() {
       ESP_LOGE(TAG, "Set internal reference failed");
       this->mark_failed();
       return;
-    } else
+    } else {
       ESP_LOGV(TAG, "Internal reference enabled");
+    }
   }
 }
 
 void DAC7678Output::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Setting up DAC7678 failed!");
-  } else
+  } else {
     ESP_LOGCONFIG(TAG, "DAC7678 initialised");
+  }
 }
 
 void DAC7678Output::register_channel(DAC7678Channel *channel) {

esphome/components/daikin_brc/__init__.py

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

esphome/components/daikin_brc/climate.py

@@ -0,0 +1,24 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate_ir
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["climate_ir"]
+
+daikin_brc_ns = cg.esphome_ns.namespace("daikin_brc")
+DaikinBrcClimate = daikin_brc_ns.class_("DaikinBrcClimate", climate_ir.ClimateIR)
+
+CONF_USE_FAHRENHEIT = "use_fahrenheit"
+
+CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(DaikinBrcClimate),
+        cv.Optional(CONF_USE_FAHRENHEIT, default=False): cv.boolean,
+    }
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await climate_ir.register_climate_ir(var, config)
+    cg.add(var.set_fahrenheit(config[CONF_USE_FAHRENHEIT]))

esphome/components/daikin_brc/daikin_brc.cpp

@@ -0,0 +1,273 @@
+#include "daikin_brc.h"
+#include "esphome/components/remote_base/remote_base.h"
+
+namespace esphome {
+namespace daikin_brc {
+
+static const char *const TAG = "daikin_brc.climate";
+
+void DaikinBrcClimate::control(const climate::ClimateCall &call) {
+  this->mode_button_ = 0x00;
+  if (call.get_mode().has_value()) {
+    // Need to determine if this is call due to Mode button pressed so that we can set the Mode button byte
+    this->mode_button_ = DAIKIN_BRC_IR_MODE_BUTTON;
+  }
+  ClimateIR::control(call);
+}
+
+void DaikinBrcClimate::transmit_state() {
+  uint8_t remote_state[DAIKIN_BRC_TRANSMIT_FRAME_SIZE] = {0x11, 0xDA, 0x17, 0x18, 0x04, 0x00, 0x1E, 0x11,
+                                                          0xDA, 0x17, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                                          0x00, 0x00, 0x00, 0x00, 0x20, 0x00};
+
+  remote_state[12] = this->alt_mode_();
+  remote_state[13] = this->mode_button_;
+  remote_state[14] = this->operation_mode_();
+  remote_state[17] = this->temperature_();
+  remote_state[18] = this->fan_speed_swing_();
+
+  // Calculate checksum
+  for (int i = DAIKIN_BRC_PREAMBLE_SIZE; i < DAIKIN_BRC_TRANSMIT_FRAME_SIZE - 1; i++) {
+    remote_state[DAIKIN_BRC_TRANSMIT_FRAME_SIZE - 1] += remote_state[i];
+  }
+
+  auto transmit = this->transmitter_->transmit();
+  auto *data = transmit.get_data();
+  data->set_carrier_frequency(DAIKIN_BRC_IR_FREQUENCY);
+
+  data->mark(DAIKIN_BRC_HEADER_MARK);
+  data->space(DAIKIN_BRC_HEADER_SPACE);
+  for (int i = 0; i < DAIKIN_BRC_PREAMBLE_SIZE; i++) {
+    for (uint8_t mask = 1; mask > 0; mask <<= 1) {  // iterate through bit mask
+      data->mark(DAIKIN_BRC_BIT_MARK);
+      bool bit = remote_state[i] & mask;
+      data->space(bit ? DAIKIN_BRC_ONE_SPACE : DAIKIN_BRC_ZERO_SPACE);
+    }
+  }
+  data->mark(DAIKIN_BRC_BIT_MARK);
+  data->space(DAIKIN_BRC_MESSAGE_SPACE);
+  data->mark(DAIKIN_BRC_HEADER_MARK);
+  data->space(DAIKIN_BRC_HEADER_SPACE);
+
+  for (int i = DAIKIN_BRC_PREAMBLE_SIZE; i < DAIKIN_BRC_TRANSMIT_FRAME_SIZE; i++) {
+    for (uint8_t mask = 1; mask > 0; mask <<= 1) {  // iterate through bit mask
+      data->mark(DAIKIN_BRC_BIT_MARK);
+      bool bit = remote_state[i] & mask;
+      data->space(bit ? DAIKIN_BRC_ONE_SPACE : DAIKIN_BRC_ZERO_SPACE);
+    }
+  }
+
+  data->mark(DAIKIN_BRC_BIT_MARK);
+  data->space(0);
+
+  transmit.perform();
+}
+
+uint8_t DaikinBrcClimate::alt_mode_() {
+  uint8_t alt_mode = 0x00;
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_DRY:
+      alt_mode = 0x23;
+      break;
+    case climate::CLIMATE_MODE_FAN_ONLY:
+      alt_mode = 0x63;
+      break;
+    case climate::CLIMATE_MODE_HEAT_COOL:
+    case climate::CLIMATE_MODE_COOL:
+    case climate::CLIMATE_MODE_HEAT:
+    default:
+      alt_mode = 0x73;
+      break;
+  }
+  return alt_mode;
+}
+
+uint8_t DaikinBrcClimate::operation_mode_() {
+  uint8_t operating_mode = DAIKIN_BRC_MODE_ON;
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_COOL:
+      operating_mode |= DAIKIN_BRC_MODE_COOL;
+      break;
+    case climate::CLIMATE_MODE_DRY:
+      operating_mode |= DAIKIN_BRC_MODE_DRY;
+      break;
+    case climate::CLIMATE_MODE_HEAT:
+      operating_mode |= DAIKIN_BRC_MODE_HEAT;
+      break;
+    case climate::CLIMATE_MODE_HEAT_COOL:
+      operating_mode |= DAIKIN_BRC_MODE_AUTO;
+      break;
+    case climate::CLIMATE_MODE_FAN_ONLY:
+      operating_mode |= DAIKIN_BRC_MODE_FAN;
+      break;
+    case climate::CLIMATE_MODE_OFF:
+    default:
+      operating_mode = DAIKIN_BRC_MODE_OFF;
+      break;
+  }
+
+  return operating_mode;
+}
+
+uint8_t DaikinBrcClimate::fan_speed_swing_() {
+  uint16_t fan_speed;
+  switch (this->fan_mode.value()) {
+    case climate::CLIMATE_FAN_LOW:
+      fan_speed = DAIKIN_BRC_FAN_1;
+      break;
+    case climate::CLIMATE_FAN_MEDIUM:
+      fan_speed = DAIKIN_BRC_FAN_2;
+      break;
+    case climate::CLIMATE_FAN_HIGH:
+      fan_speed = DAIKIN_BRC_FAN_3;
+      break;
+    default:
+      fan_speed = DAIKIN_BRC_FAN_1;
+  }
+
+  // If swing is enabled switch first 4 bits to 1111
+  switch (this->swing_mode) {
+    case climate::CLIMATE_SWING_BOTH:
+      fan_speed |= DAIKIN_BRC_IR_SWING_ON;
+      break;
+    default:
+      fan_speed |= DAIKIN_BRC_IR_SWING_OFF;
+      break;
+  }
+  return fan_speed;
+}
+
+uint8_t DaikinBrcClimate::temperature_() {
+  // Force special temperatures depending on the mode
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_FAN_ONLY:
+    case climate::CLIMATE_MODE_DRY:
+      if (this->fahrenheit_) {
+        return DAIKIN_BRC_IR_DRY_FAN_TEMP_F;
+      }
+      return DAIKIN_BRC_IR_DRY_FAN_TEMP_C;
+    case climate::CLIMATE_MODE_HEAT_COOL:
+    default:
+      uint8_t temperature;
+      // Temperature in remote is in F
+      if (this->fahrenheit_) {
+        temperature = (uint8_t) roundf(
+            clamp<float>(((this->target_temperature * 1.8) + 32), DAIKIN_BRC_TEMP_MIN_F, DAIKIN_BRC_TEMP_MAX_F));
+      } else {
+        temperature = ((uint8_t) roundf(this->target_temperature) - 9) << 1;
+      }
+      return temperature;
+  }
+}
+
+bool DaikinBrcClimate::parse_state_frame_(const uint8_t frame[]) {
+  uint8_t checksum = 0;
+  for (int i = 0; i < (DAIKIN_BRC_STATE_FRAME_SIZE - 1); i++) {
+    checksum += frame[i];
+  }
+  if (frame[DAIKIN_BRC_STATE_FRAME_SIZE - 1] != checksum) {
+    ESP_LOGCONFIG(TAG, "Bad CheckSum %x", checksum);
+    return false;
+  }
+
+  uint8_t mode = frame[7];
+  if (mode & DAIKIN_BRC_MODE_ON) {
+    switch (mode & 0xF0) {
+      case DAIKIN_BRC_MODE_COOL:
+        this->mode = climate::CLIMATE_MODE_COOL;
+        break;
+      case DAIKIN_BRC_MODE_DRY:
+        this->mode = climate::CLIMATE_MODE_DRY;
+        break;
+      case DAIKIN_BRC_MODE_HEAT:
+        this->mode = climate::CLIMATE_MODE_HEAT;
+        break;
+      case DAIKIN_BRC_MODE_AUTO:
+        this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+        break;
+      case DAIKIN_BRC_MODE_FAN:
+        this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+        break;
+    }
+  } else {
+    this->mode = climate::CLIMATE_MODE_OFF;
+  }
+
+  uint8_t temperature = frame[10];
+  float temperature_c;
+  if (this->fahrenheit_) {
+    temperature_c = clamp<float>(((temperature - 32) / 1.8), DAIKIN_BRC_TEMP_MIN_C, DAIKIN_BRC_TEMP_MAX_C);
+  } else {
+    temperature_c = (temperature >> 1) + 9;
+  }
+
+  this->target_temperature = temperature_c;
+
+  uint8_t fan_mode = frame[11];
+  uint8_t swing_mode = frame[11];
+  switch (swing_mode & 0xF) {
+    case DAIKIN_BRC_IR_SWING_ON:
+      this->swing_mode = climate::CLIMATE_SWING_BOTH;
+      break;
+    case DAIKIN_BRC_IR_SWING_OFF:
+      this->swing_mode = climate::CLIMATE_SWING_OFF;
+      break;
+  }
+
+  switch (fan_mode & 0xF0) {
+    case DAIKIN_BRC_FAN_1:
+      this->fan_mode = climate::CLIMATE_FAN_LOW;
+      break;
+    case DAIKIN_BRC_FAN_2:
+      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      break;
+    case DAIKIN_BRC_FAN_3:
+      this->fan_mode = climate::CLIMATE_FAN_HIGH;
+      break;
+  }
+  this->publish_state();
+  return true;
+}
+
+bool DaikinBrcClimate::on_receive(remote_base::RemoteReceiveData data) {
+  uint8_t state_frame[DAIKIN_BRC_STATE_FRAME_SIZE] = {};
+  if (!data.expect_item(DAIKIN_BRC_HEADER_MARK, DAIKIN_BRC_HEADER_SPACE)) {
+    return false;
+  }
+  for (uint8_t pos = 0; pos < DAIKIN_BRC_STATE_FRAME_SIZE; pos++) {
+    uint8_t byte = 0;
+    for (int8_t bit = 0; bit < 8; bit++) {
+      if (data.expect_item(DAIKIN_BRC_BIT_MARK, DAIKIN_BRC_ONE_SPACE)) {
+        byte |= 1 << bit;
+      } else if (!data.expect_item(DAIKIN_BRC_BIT_MARK, DAIKIN_BRC_ZERO_SPACE)) {
+        return false;
+      }
+    }
+    state_frame[pos] = byte;
+    if (pos == 0) {
+      // frame header
+      if (byte != 0x11)
+        return false;
+    } else if (pos == 1) {
+      // frame header
+      if (byte != 0xDA)
+        return false;
+    } else if (pos == 2) {
+      // frame header
+      if (byte != 0x17)
+        return false;
+    } else if (pos == 3) {
+      // frame header
+      if (byte != 0x18)
+        return false;
+    } else if (pos == 4) {
+      // frame type
+      if (byte != 0x00)
+        return false;
+    }
+  }
+  return this->parse_state_frame_(state_frame);
+}
+
+}  // namespace daikin_brc
+}  // namespace esphome

esphome/components/daikin_brc/daikin_brc.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "esphome/components/climate_ir/climate_ir.h"
+
+namespace esphome {
+namespace daikin_brc {
+
+// Values for Daikin BRC4CXXX IR Controllers
+// Temperature
+const uint8_t DAIKIN_BRC_TEMP_MIN_F = 60;                                // fahrenheit
+const uint8_t DAIKIN_BRC_TEMP_MAX_F = 90;                                // fahrenheit
+const float DAIKIN_BRC_TEMP_MIN_C = (DAIKIN_BRC_TEMP_MIN_F - 32) / 1.8;  // fahrenheit
+const float DAIKIN_BRC_TEMP_MAX_C = (DAIKIN_BRC_TEMP_MAX_F - 32) / 1.8;  // fahrenheit
+
+// Modes
+const uint8_t DAIKIN_BRC_MODE_AUTO = 0x30;
+const uint8_t DAIKIN_BRC_MODE_COOL = 0x20;
+const uint8_t DAIKIN_BRC_MODE_HEAT = 0x10;
+const uint8_t DAIKIN_BRC_MODE_DRY = 0x70;
+const uint8_t DAIKIN_BRC_MODE_FAN = 0x00;
+const uint8_t DAIKIN_BRC_MODE_OFF = 0x00;
+const uint8_t DAIKIN_BRC_MODE_ON = 0x01;
+
+// Fan Speed
+const uint8_t DAIKIN_BRC_FAN_1 = 0x10;
+const uint8_t DAIKIN_BRC_FAN_2 = 0x30;
+const uint8_t DAIKIN_BRC_FAN_3 = 0x50;
+const uint8_t DAIKIN_BRC_FAN_AUTO = 0xA0;
+
+// IR Transmission
+const uint32_t DAIKIN_BRC_IR_FREQUENCY = 38000;
+const uint32_t DAIKIN_BRC_HEADER_MARK = 5070;
+const uint32_t DAIKIN_BRC_HEADER_SPACE = 2140;
+const uint32_t DAIKIN_BRC_BIT_MARK = 370;
+const uint32_t DAIKIN_BRC_ONE_SPACE = 1780;
+const uint32_t DAIKIN_BRC_ZERO_SPACE = 710;
+const uint32_t DAIKIN_BRC_MESSAGE_SPACE = 29410;
+
+const uint8_t DAIKIN_BRC_IR_DRY_FAN_TEMP_F = 72;            // Dry/Fan mode is always 17 Celsius.
+const uint8_t DAIKIN_BRC_IR_DRY_FAN_TEMP_C = (17 - 9) * 2;  // Dry/Fan mode is always 17 Celsius.
+const uint8_t DAIKIN_BRC_IR_SWING_ON = 0x5;
+const uint8_t DAIKIN_BRC_IR_SWING_OFF = 0x6;
+const uint8_t DAIKIN_BRC_IR_MODE_BUTTON = 0x4;  // This is set after a mode action
+
+// State Frame size
+const uint8_t DAIKIN_BRC_STATE_FRAME_SIZE = 15;
+// Preamble size
+const uint8_t DAIKIN_BRC_PREAMBLE_SIZE = 7;
+// Transmit Frame size - includes a preamble
+const uint8_t DAIKIN_BRC_TRANSMIT_FRAME_SIZE = DAIKIN_BRC_PREAMBLE_SIZE + DAIKIN_BRC_STATE_FRAME_SIZE;
+
+class DaikinBrcClimate : public climate_ir::ClimateIR {
+ public:
+  DaikinBrcClimate()
+      : climate_ir::ClimateIR(DAIKIN_BRC_TEMP_MIN_C, DAIKIN_BRC_TEMP_MAX_C, 0.5f, true, true,
+                              {climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH}) {}
+
+  /// Set use of Fahrenheit units
+  void set_fahrenheit(bool value) {
+    this->fahrenheit_ = value;
+    this->temperature_step_ = value ? 0.5f : 1.0f;
+  }
+
+ protected:
+  uint8_t mode_button_ = 0x00;
+  // Capture if the MODE was changed
+  void control(const climate::ClimateCall &call) override;
+  // Transmit via IR the state of this climate controller.
+  void transmit_state() override;
+  uint8_t alt_mode_();
+  uint8_t operation_mode_();
+  uint8_t fan_speed_swing_();
+  uint8_t temperature_();
+  // Handle received IR Buffer
+  bool on_receive(remote_base::RemoteReceiveData data) override;
+  bool parse_state_frame_(const uint8_t frame[]);
+  bool fahrenheit_{false};
+};
+
+}  // namespace daikin_brc
+}  // namespace esphome