Merge pull request #2160 from esphome/bump-1.21.0b2

1.21.0b2

.clang-format

@@ -49,7 +49,7 @@ ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
-DerivePointerAlignment: true
+DerivePointerAlignment: false
 DisableFormat:   false
 ExperimentalAutoDetectBinPacking: false
 FixNamespaceComments: true

.clang-tidy

@@ -4,14 +4,29 @@ Checks: >-
   -abseil-*,
   -android-*,
   -boost-*,
-  -bugprone-macro-parentheses,
+  -bugprone-branch-clone,
+  -bugprone-narrowing-conversions,
+  -bugprone-signed-char-misuse,
+  -bugprone-too-small-loop-variable,
   -cert-dcl50-cpp,
   -cert-err58-cpp,
-  -clang-analyzer-core.CallAndMessage,
+  -cert-oop57-cpp,
+  -cert-str34-c,
+  -clang-analyzer-optin.cplusplus.UninitializedObject,
   -clang-analyzer-osx.*,
-  -clang-analyzer-security.*,
+  -clang-diagnostic-delete-abstract-non-virtual-dtor,
+  -clang-diagnostic-delete-non-abstract-non-virtual-dtor,
+  -clang-diagnostic-shadow-field,
+  -clang-diagnostic-sign-compare,
+  -clang-diagnostic-unused-variable,
+  -clang-diagnostic-unused-const-variable,
+  -cppcoreguidelines-avoid-c-arrays,
   -cppcoreguidelines-avoid-goto,
-  -cppcoreguidelines-c-copy-assignment-signature,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-constant-array-index,
@@ -24,42 +39,52 @@ Checks: >-
   -cppcoreguidelines-pro-type-union-access,
   -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-special-member-functions,
-  -fuchsia-*,
   -fuchsia-default-arguments,
   -fuchsia-multiple-inheritance,
   -fuchsia-overloaded-operator,
   -fuchsia-statically-constructed-objects,
+  -fuchsia-default-arguments-declarations,
+  -fuchsia-default-arguments-calls,
   -google-build-using-namespace,
   -google-explicit-constructor,
   -google-readability-braces-around-statements,
   -google-readability-casting,
   -google-readability-todo,
-  -google-runtime-int,
   -google-runtime-references,
   -hicpp-*,
+  -llvm-else-after-return,
   -llvm-header-guard,
   -llvm-include-order,
-  -misc-unconventional-assign-operator,
+  -llvm-qualified-auto,
+  -llvmlibc-*,
+  -misc-non-private-member-variables-in-classes,
+  -misc-no-recursion,
   -misc-unused-parameters,
-  -modernize-deprecated-headers,
-  -modernize-pass-by-value,
-  -modernize-pass-by-value,
+  -modernize-avoid-c-arrays,
   -modernize-return-braced-init-list,
   -modernize-use-auto,
   -modernize-use-default-member-init,
   -modernize-use-equals-default,
+  -modernize-use-trailing-return-type,
   -mpi-*,
   -objc-*,
-  -performance-unnecessary-value-param,
   -readability-braces-around-statements,
+  -readability-const-return-type,
+  -readability-convert-member-functions-to-static,
   -readability-else-after-return,
   -readability-implicit-bool-conversion,
+  -readability-isolate-declaration,
+  -readability-magic-numbers,
+  -readability-make-member-function-const,
   -readability-named-parameter,
+  -readability-qualified-auto,
+  -readability-redundant-access-specifiers,
   -readability-redundant-member-init,
-  -warnings-as-errors,
-  -zircon-*
+  -readability-redundant-string-init,
+  -readability-uppercase-literal-suffix,
+  -readability-use-anyofallof,
+  -warnings-as-errors
 WarningsAsErrors: '*'
-HeaderFilterRegex: '^.*/src/esphome/.*'
 AnalyzeTemporaryDtors: false
 FormatStyle:     google
 CheckOptions:

.devcontainer/devcontainer.json

@@ -2,16 +2,29 @@
   "name": "ESPHome Dev",
   "context": "..",
   "dockerFile": "../docker/Dockerfile.dev",
-  "postCreateCommand": "mkdir -p config && pip3 install -e .",
-  "runArgs": ["--privileged", "-e", "ESPHOME_DASHBOARD_USE_PING=1"],
+  "postCreateCommand": [
+    "script/devcontainer-post-create"
+  ],
+  "runArgs": [
+    "--privileged",
+    "-e",
+    "ESPHOME_DASHBOARD_USE_PING=1"
+  ],
   "appPort": 6052,
   "extensions": [
+    // python
     "ms-python.python",
     "visualstudioexptteam.vscodeintellicode",
-    "redhat.vscode-yaml"
+    // yaml
+    "redhat.vscode-yaml",
+    // cpp
+    "ms-vscode.cpptools",
+    // editorconfig
+    "editorconfig.editorconfig",
   ],
   "settings": {
-    "python.pythonPath": "/usr/local/bin/python",
+    "python.languageServer": "Pylance",
+    "python.pythonPath": "/usr/bin/python3",
     "python.linting.pylintEnabled": true,
     "python.linting.enabled": true,
     "python.formatting.provider": "black",
@@ -19,7 +32,7 @@
     "editor.formatOnSave": true,
     "editor.formatOnType": true,
     "files.trimTrailingWhitespace": true,
-    "terminal.integrated.shell.linux": "/bin/bash",
+    "terminal.integrated.defaultProfile.linux": "bash",
     "yaml.customTags": [
       "!secret scalar",
       "!lambda scalar",
@@ -27,6 +40,18 @@
       "!include_dir_list scalar",
       "!include_dir_merge_list scalar",
       "!include_dir_merge_named scalar"
-    ]
+    ],
+    "files.exclude": {
+      "**/.git": true,
+      "**/.DS_Store": true,
+      "**/*.pyc": {
+        "when": "$(basename).py"
+      },
+      "**/__pycache__": true
+    },
+    "files.associations": {
+      "**/.vscode/*.json": "jsonc"
+    },
+    "C_Cpp.clang_format_path": "/usr/bin/clang-format-11",
   }
 }

.dockerignore

@@ -103,6 +103,10 @@ venv.bak/
 # mypy
 .mypy_cache/
 
+# PlatformIO
+.pio/
+
+# ESPHome
 config/
 examples/
 Dockerfile

.editorconfig

@@ -7,7 +7,7 @@ insert_final_newline = true
 charset = utf-8
 
 # python
-[*.{py}]
+[*.py]
 indent_style = space
 indent_size = 4
 
@@ -25,3 +25,10 @@ indent_size = 2
 [*.{yaml,yml}]
 indent_style = space
 indent_size = 2
+quote_type = single
+
+# JSON
+[*.json]
+indent_style = space
+indent_size = 2
+

.github/FUNDING.yml

@@ -1,8 +1,3 @@
 # These are supported funding model platforms
 
-github:
-patreon: ottowinter
-open_collective:
-ko_fi:
-tidelift:
-custom: https://esphome.io/guides/supporters.html
+custom: https://www.nabucasa.com

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,13 +1,39 @@
-## Description:
+# What does this implement/fix? 
 
+Quick description and explanation of changes
 
-**Related issue (if applicable):** fixes <link to issue>
+## Types of changes
+
+- [ ] Bugfix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Other
+
+**Related issue or feature (if applicable):** fixes <link to issue>
 
 **Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here>
 
+## Test Environment
+
+- [ ] ESP32
+- [ ] ESP8266
+
+## Example entry for `config.yaml`:
+<!--
+  Supplying a configuration snippet, makes it easier for a maintainer to test
+  your PR. Furthermore, for new integrations, it gives an impression of how
+  the configuration would look like.
+  Note: Remove this section if this PR does not have an example entry.
+-->
+
+```yaml
+# Example config.yaml
+
+```
+
 ## Checklist:
   - [ ] The code change is tested and works locally.
   - [ ] Tests have been added to verify that the new code works (under `tests/` folder).
-
+  
 If user exposed functionality or configuration variables are added/changed:
   - [ ] Documentation added/updated in [esphome-docs](https://github.com/esphome/esphome-docs).

.github/workflows/ci-docker.yml

@@ -3,7 +3,7 @@ name: CI for docker images
 # Only run when docker paths change
 on:
   push:
-    branches: [dev, beta, master]
+    branches: [dev, beta, release]
     paths:
       - 'docker/**'
       - '.github/workflows/**'
@@ -20,35 +20,21 @@ jobs:
     strategy:
       matrix:
         arch: [amd64, armv7, aarch64]
-        build_type: ["hassio", "docker"]
+        build_type: ["ha-addon", "docker", "lint"]
     steps:
-      - uses: actions/checkout@v2
-      - name: Set up env variables
-        run: |
-          base_version="2.6.0"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=check" >> $GITHUB_ENV
 
-          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
-            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile.hassio"
-          else
-            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile"
-          fi
-
-          echo "::set-env name=BUILD_FROM::${build_from}"
-          echo "::set-env name=BUILD_TO::${build_to}"
-          echo "::set-env name=DOCKERFILE::${dockerfile}"
-      - name: Pull for cache
-        run: |
-          docker pull "${BUILD_TO}:dev" || true
-      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
-      - run: |
-          docker build \
-            --build-arg "BUILD_FROM=${BUILD_FROM}" \
-            --build-arg "BUILD_VERSION=ci" \
-            --cache-from "${BUILD_TO}:dev" \
-            --file "${DOCKERFILE}" \
-            .
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build

.github/workflows/ci.yml

@@ -4,160 +4,98 @@ name: CI
 
 on:
   push:
-    # On dev branch release-dev already performs CI checks
-    # On other branches the `pull_request` trigger will be used
-    branches: [beta, master]
+    branches: [dev, beta, release]
 
   pull_request:
 
 jobs:
-  # A fast overview job that checks only changed files
-  overview:
+  ci-with-container:
+    name: ${{ matrix.name }}
     runs-on: ubuntu-latest
-    container: esphome/esphome-lint:latest
-    steps:
-      # Also fetch history and dev branch so that we can check which files changed
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - name: Fetch dev branch
-        run: git fetch origin dev
-
-      # Cache the .pio directory with (primarily) library dependencies
-      - name: Cache .pio lib_deps
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      - name: Set up python environment
-        run: script/setup
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
-          echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Run a quick lint over all changed files
-        run: script/quicklint
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-clang-format:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
-    steps:
-      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-      - name: Run clang-format
-        run: script/clang-format -i
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-clang-tidy:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
-    # Split clang-tidy check into 4 jobs. Each one will check 1/4th of the .cpp files
     strategy:
+      fail-fast: false
       matrix:
-        split: [1, 2, 3, 4]
+        include:
+          - id: clang-format
+            name: Run script/clang-format
+          - id: clang-tidy
+            name: Run script/clang-tidy 1/4
+            split: 1
+          - id: clang-tidy
+            name: Run script/clang-tidy 2/4
+            split: 2
+          - id: clang-tidy
+            name: Run script/clang-tidy 3/4
+            split: 3
+          - id: clang-tidy
+            name: Run script/clang-tidy 4/4
+            split: 4
+
+    # cpp lint job runs with esphome-lint docker image so that clang-format-*
+    # doesn't have to be installed
+    container: ghcr.io/esphome/esphome-lint:1.1
     steps:
       - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
 
       - name: Register problem matchers
         run: |
           echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
           echo "::add-matcher::.github/workflows/matchers/gcc.json"
+
+      # Also run git-diff-index so that the step is marked as failed on formatting errors,
+      # since clang-format doesn't do anything but change files if -i is passed.
+      - name: Run clang-format
+        run: |
+          script/clang-format -i
+          git diff-index --quiet HEAD --
+        if: ${{ matrix.id == 'clang-format' }}
+
       - name: Run clang-tidy
         run: script/clang-tidy --all-headers --fix --split-num 4 --split-at ${{ matrix.split }}
-      - name: Suggest changes
-        run: script/ci-suggest-changes
+        if: ${{ matrix.id == 'clang-tidy' }}
 
-  lint-python:
+      - name: Suggested changes
+        run: script/ci-suggest-changes
+        if: always()
+
+  ci:
     # Don't use the esphome-lint docker image because it may contain outdated requirements.
     # This way, all dependencies are cached via the cache action.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up python environment
-        run: script/setup
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
-          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Lint Custom
-        run: script/ci-custom.py
-      - name: Lint Python
-        run: script/lint-python
-      - name: Lint CODEOWNERS
-        run: script/build_codeowners.py --check
-
-  test:
+    name: ${{ matrix.name }}
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
-          test:
-          - test1
-          - test2
-          - test3
-          - test4
+        include:
+          - id: ci-custom
+            name: Run script/ci-custom
+          - id: lint-python
+            name: Run script/lint-python
+          - id: test
+            file: tests/test1.yaml
+            name: Test tests/test1.yaml
+          - id: test
+            file: tests/test2.yaml
+            name: Test tests/test2.yaml
+          - id: test
+            file: tests/test3.yaml
+            name: Test tests/test3.yaml
+          - id: test
+            file: tests/test4.yaml
+            name: Test tests/test4.yaml
+          - id: test
+            file: tests/test5.yaml
+            name: Test tests/test5.yaml
+          - id: pytest
+            name: Run pytest
+
     steps:
       - uses: actions/checkout@v2
       - name: Set up Python
         uses: actions/setup-python@v2
         with:
           python-version: '3.7'
+
       - name: Cache pip modules
         uses: actions/cache@v1
         with:
@@ -165,51 +103,41 @@ jobs:
           key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
           restore-keys: |
             esphome-pip-3.7-
+
       # Use per test platformio cache because tests have different platform versions
       - name: Cache ~/.platformio
         uses: actions/cache@v1
         with:
           path: ~/.platformio
-          key: test-home-platformio-${{ matrix.test }}-${{ hashFiles('esphome/core_config.py') }}
+          key: test-home-platformio-${{ matrix.file }}-${{ hashFiles('esphome/core/config.py') }}
           restore-keys: |
-            test-home-platformio-${{ matrix.test }}-
-      - name: Set up environment
-        run: script/setup
+            test-home-platformio-${{ matrix.file }}-
+        if: ${{ matrix.id == 'test' }}
 
+      - name: Set up python environment
+        run: script/setup
 
       - name: Register problem matchers
         run: |
+          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
+          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
+          echo "::add-matcher::.github/workflows/matchers/python.json"
+          echo "::add-matcher::.github/workflows/matchers/pytest.json"
           echo "::add-matcher::.github/workflows/matchers/gcc.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - run: esphome tests/${{ matrix.test }}.yaml compile
 
-  pytest:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up environment
-        run: script/setup
-      - name: Install Github Actions annotator
-        run: pip install pytest-github-actions-annotate-failures
-
-      - name: Register problem matchers
+      - name: Lint Custom
         run: |
-          echo "::add-matcher::.github/workflows/matchers/python.json"
+          script/ci-custom.py
+          script/build_codeowners.py --check
+        if: ${{ matrix.id == 'ci-custom' }}
+      - name: Lint Python
+        run: script/lint-python
+        if: ${{ matrix.id == 'lint-python' }}
+
+      - run: esphome compile ${{ matrix.file }}
+        if: ${{ matrix.id == 'test' }}
+
       - name: Run pytest
         run: |
-          pytest \
-            -qq \
-            --durations=10 \
-            -o console_output_style=count \
-            tests
+          pytest -vv --tb=native tests
+        if: ${{ matrix.id == 'pytest' }}

.github/workflows/docker-lint-build.yml

@@ -0,0 +1,100 @@
+name: Build and publish lint docker image
+
+# Only run when docker paths change
+on:
+  push:
+    branches: [dev]
+    paths:
+      - 'docker/Dockerfile.lint'
+      - 'requirements.txt'
+      - 'requirements_optional.txt'
+      - 'requirements_test.txt'
+      - 'platformio.ini'
+      - '.github/workflows/docker-lint-build.yml'
+
+jobs:
+  deploy-docker:
+    name: Build and publish docker containers
+    if: github.repository == 'esphome/esphome'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        arch: [amd64, armv7, aarch64]
+        build_type: ["lint"]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=1.1" >> $GITHUB_ENV
+
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build
+
+    - name: Log in to docker hub
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Run push
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          push
+
+  deploy-docker-manifest:
+    if: github.repository == 'esphome/esphome'
+    runs-on: ubuntu-latest
+    needs: [deploy-docker]
+    strategy:
+      matrix:
+        build_type: ["lint"]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=1.1" >> $GITHUB_ENV
+    - 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@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Run manifest
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --build-type "${{ matrix.build_type }}" \
+          manifest

.github/workflows/matchers/pytest.json

@@ -0,0 +1,19 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "pytest",
+      "fileLocation": "absolute",
+      "pattern": [
+        {
+          "regexp": "^\\s+File \"(.*)\", line (\\d+), in (.*)$",
+          "file": 1,
+          "line": 2
+        },
+        {
+          "regexp": "^\\s+(.*)$",
+          "message": 1
+        }
+      ]
+    }
+  ]
+}

.github/workflows/release-dev.yml

@@ -1,262 +0,0 @@
-name: Publish dev releases to docker hub
-
-on:
-  push:
-    branches:
-    - dev
-
-jobs:
-  # THE LINT/TEST JOBS ARE COPIED FROM ci.yaml
-
-  lint-clang-format:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
-    steps:
-      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-      - name: Run clang-format
-        run: script/clang-format -i
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-clang-tidy:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
-    # Split clang-tidy check into 4 jobs. Each one will check 1/4th of the .cpp files
-    strategy:
-      matrix:
-        split: [1, 2, 3, 4]
-    steps:
-      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-      - name: Run clang-tidy
-        run: script/clang-tidy --all-headers --fix --split-num 4 --split-at ${{ matrix.split }}
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-python:
-    # Don't use the esphome-lint docker image because it may contain outdated requirements.
-    # This way, all dependencies are cached via the cache action.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up python environment
-        run: script/setup
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
-          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Lint Custom
-        run: script/ci-custom.py
-      - name: Lint Python
-        run: script/lint-python
-      - name: Lint CODEOWNERS
-        run: script/build_codeowners.py --check
-
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-          test:
-          - test1
-          - test2
-          - test3
-          - test4
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      # Use per test platformio cache because tests have different platform versions
-      - name: Cache ~/.platformio
-        uses: actions/cache@v1
-        with:
-          path: ~/.platformio
-          key: test-home-platformio-${{ matrix.test }}-${{ hashFiles('esphome/core_config.py') }}
-          restore-keys: |
-            test-home-platformio-${{ matrix.test }}-
-      - name: Set up environment
-        run: script/setup
-
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - run: esphome tests/${{ matrix.test }}.yaml compile
-
-  pytest:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up environment
-        run: script/setup
-      - name: Install Github Actions annotator
-        run: pip install pytest-github-actions-annotate-failures
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Run pytest
-        run: |
-          pytest \
-            -qq \
-            --durations=10 \
-            -o console_output_style=count \
-            tests
-
-  deploy-docker:
-    name: Build and publish docker containers
-    if: github.repository == 'esphome/esphome'
-    runs-on: ubuntu-latest
-    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
-    strategy:
-      matrix:
-        arch: [amd64, armv7, aarch64]
-        # Hassio dev image doesn't use esphome/esphome-hassio-$arch and uses base directly
-        build_type: ["docker"]
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set TAG
-        run: |
-          TAG="${GITHUB_SHA:0:7}"
-          echo "::set-env name=TAG::${TAG}"
-      - name: Set up env variables
-        run: |
-          base_version="2.6.0"
-
-          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
-            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile.hassio"
-          else
-            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile"
-          fi
-
-          echo "::set-env name=BUILD_FROM::${build_from}"
-          echo "::set-env name=BUILD_TO::${build_to}"
-          echo "::set-env name=DOCKERFILE::${dockerfile}"
-      - name: Pull for cache
-        run: |
-          docker pull "${BUILD_TO}:dev" || true
-      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
-      - run: |
-          docker build \
-            --build-arg "BUILD_FROM=${BUILD_FROM}" \
-            --build-arg "BUILD_VERSION=${TAG}" \
-            --tag "${BUILD_TO}:${TAG}" \
-            --tag "${BUILD_TO}:dev" \
-            --cache-from "${BUILD_TO}:dev" \
-            --file "${DOCKERFILE}" \
-            .
-      - name: Log in to docker hub
-        env:
-          DOCKER_USER: ${{ secrets.DOCKER_USER }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-        run: docker login -u "${DOCKER_USER}" -p "${DOCKER_PASSWORD}"
-      - run: |
-          docker push "${BUILD_TO}:${TAG}"
-          docker push "${BUILD_TO}:dev"
-
-
-  deploy-docker-manifest:
-    if: github.repository == 'esphome/esphome'
-    runs-on: ubuntu-latest
-    needs: [deploy-docker]
-    steps:
-    - name: Enable experimental manifest support
-      run: |
-        mkdir -p ~/.docker
-        echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
-    - name: Set TAG
-      run: |
-        TAG="${GITHUB_SHA:0:7}"
-        echo "::set-env name=TAG::${TAG}"
-    - name: Log in to docker hub
-      env:
-        DOCKER_USER: ${{ secrets.DOCKER_USER }}
-        DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-      run: docker login -u "${DOCKER_USER}" -p "${DOCKER_PASSWORD}"
-    - name: "Create the manifest"
-      run: |
-        docker manifest create esphome/esphome:${TAG} \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:${TAG}
-
-        docker manifest create esphome/esphome:dev \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:dev

.github/workflows/release.yml

@@ -1,179 +1,35 @@
 name: Publish Release
 
 on:
+  workflow_dispatch:
   release:
     types: [published]
+  schedule:
+    - cron: "0 2 * * *"
 
 jobs:
-  # THE LINT/TEST JOBS ARE COPIED FROM ci.yaml
-
-  lint-clang-format:
+  init:
+    name: Initialize build
     runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
     steps:
       - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-      - name: Run clang-format
-        run: script/clang-format -i
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-clang-tidy:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:latest
-    # Split clang-tidy check into 4 jobs. Each one will check 1/4th of the .cpp files
-    strategy:
-      matrix:
-        split: [1, 2, 3, 4]
-    steps:
-      - uses: actions/checkout@v2
-      # Cache platformio intermediary files (like libraries etc)
-      # Note: platformio platform versions should be cached via the esphome-lint image
-      - name: Cache Platformio
-        uses: actions/cache@v1
-        with:
-          path: .pio
-          key: lint-cpp-pio-${{ hashFiles('platformio.ini') }}
-          restore-keys: |
-            lint-cpp-pio-
-      # Set up the pio project so that the cpp checks know how files are compiled
-      # (build flags, libraries etc)
-      - name: Set up platformio environment
-        run: pio init --ide atom
-
-
-      - name: Register problem matchers
+      - name: Get tag
+        id: tag
         run: |
-          echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-      - name: Run clang-tidy
-        run: script/clang-tidy --all-headers --fix --split-num 4 --split-at ${{ matrix.split }}
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-python:
-    # Don't use the esphome-lint docker image because it may contain outdated requirements.
-    # This way, all dependencies are cached via the cache action.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up python environment
-        run: script/setup
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
-          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Lint Custom
-        run: script/ci-custom.py
-      - name: Lint Python
-        run: script/lint-python
-      - name: Lint CODEOWNERS
-        run: script/build_codeowners.py --check
-
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-          test:
-          - test1
-          - test2
-          - test3
-          - test4
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      # Use per test platformio cache because tests have different platform versions
-      - name: Cache ~/.platformio
-        uses: actions/cache@v1
-        with:
-          path: ~/.platformio
-          key: test-home-platformio-${{ matrix.test }}-${{ hashFiles('esphome/core_config.py') }}
-          restore-keys: |
-            test-home-platformio-${{ matrix.test }}-
-      - name: Set up environment
-        run: script/setup
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - run: esphome tests/${{ matrix.test }}.yaml compile
-
-  pytest:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up environment
-        run: script/setup
-      - name: Install Github Actions annotator
-        run: pip install pytest-github-actions-annotate-failures
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Run pytest
-        run: |
-          pytest \
-            -qq \
-            --durations=10 \
-            -o console_output_style=count \
-            tests
+          if [[ "$GITHUB_EVENT_NAME" = "release" ]]; then
+            TAG="${GITHUB_REF#refs/tags/v}"
+          else
+            TAG=$(cat esphome/const.py | sed -n -E "s/^__version__\s+=\s+\"(.+)\"$/\1/p")
+            today="$(date --utc '+%Y%m%d')"
+            TAG="${TAG}${today}"
+          fi
+          echo "::set-output name=tag::${TAG}"
 
   deploy-pypi:
     name: Build and publish to PyPi
-    if: github.repository == 'esphome/esphome'
-    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
+    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -197,119 +53,85 @@ jobs:
     name: Build and publish docker containers
     if: github.repository == 'esphome/esphome'
     runs-on: ubuntu-latest
-    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
+    needs: [init]
     strategy:
       matrix:
         arch: [amd64, armv7, aarch64]
-        build_type: ["hassio", "docker"]
+        build_type: ["ha-addon", "docker"]
     steps:
-      - uses: actions/checkout@v2
-      - name: Set TAG
-        run: |
-          TAG="${GITHUB_REF#refs/tags/v}"
-          echo "::set-env name=TAG::${TAG}"
-      - name: Set up env variables
-        run: |
-          base_version="2.6.0"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
 
-          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
-            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile.hassio"
-          else
-            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile"
-          fi
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build
 
-          if [[ "${{ github.event.release.prerelease }}" == "true" ]]; then
-            cache_tag="beta"
-          else
-            cache_tag="latest"
-          fi
+    - name: Log in to docker hub
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-          # Set env variables so these values don't need to be calculated again
-          echo "::set-env name=BUILD_FROM::${build_from}"
-          echo "::set-env name=BUILD_TO::${build_to}"
-          echo "::set-env name=DOCKERFILE::${dockerfile}"
-          echo "::set-env name=CACHE_TAG::${cache_tag}"
-      - name: Pull for cache
-        run: |
-          docker pull "${BUILD_TO}:${CACHE_TAG}" || true
-      - name: Register QEMU binfmt
-        run: docker run --rm --privileged multiarch/qemu-user-static:5.0.0-2 --reset -p yes
-      - run: |
-          docker build \
-            --build-arg "BUILD_FROM=${BUILD_FROM}" \
-            --build-arg "BUILD_VERSION=${TAG}" \
-            --tag "${BUILD_TO}:${TAG}" \
-            --cache-from "${BUILD_TO}:${CACHE_TAG}" \
-            --file "${DOCKERFILE}" \
-            .
-      - name: Log in to docker hub
-        env:
-          DOCKER_USER: ${{ secrets.DOCKER_USER }}
-          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-        run: docker login -u "${DOCKER_USER}" -p "${DOCKER_PASSWORD}"
-      - run: docker push "${BUILD_TO}:${TAG}"
-
-      # Always publish to beta tag (also full releases)
-      - name: Publish docker beta tag
-        run: |
-          docker tag "${BUILD_TO}:${TAG}" "${BUILD_TO}:beta"
-          docker push "${BUILD_TO}:beta"
-
-      - if: ${{ !github.event.release.prerelease }}
-        name: Publish docker latest tag
-        run: |
-          docker tag "${BUILD_TO}:${TAG}" "${BUILD_TO}:latest"
-          docker push "${BUILD_TO}:latest"
+    - name: Run push
+      run: |
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          push
 
   deploy-docker-manifest:
     if: github.repository == 'esphome/esphome'
     runs-on: ubuntu-latest
-    needs: [deploy-docker]
+    needs: [init, deploy-docker]
+    strategy:
+      matrix:
+        build_type: ["ha-addon", "docker"]
     steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
     - name: Enable experimental manifest support
       run: |
         mkdir -p ~/.docker
         echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
-    - name: Set TAG
-      run: |
-        TAG="${GITHUB_REF#refs/tags/v}"
-        echo "::set-env name=TAG::${TAG}"
+
     - name: Log in to docker hub
-      env:
-        DOCKER_USER: ${{ secrets.DOCKER_USER }}
-        DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
-      run: docker login -u "${DOCKER_USER}" -p "${DOCKER_PASSWORD}"
-    - name: "Create the manifest"
-      run: |
-        docker manifest create esphome/esphome:${TAG} \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:${TAG}
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-    - name: Publish docker beta tag
+    - name: Run manifest
       run: |
-        docker manifest create esphome/esphome:beta \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:beta
-
-    - name: Publish docker latest tag
-      if: ${{ !github.event.release.prerelease }}
-      run: |
-        docker manifest create esphome/esphome:latest \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:latest
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --build-type "${{ matrix.build_type }}" \
+          manifest
 
   deploy-hassio-repo:
-    if: github.repository == 'esphome/esphome'
+    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
     needs: [deploy-docker]
     steps:
@@ -322,4 +144,4 @@ jobs:
             -X POST \
             -H "Accept: application/vnd.github.v3+json" \
             https://api.github.com/repos/esphome/hassio/actions/workflows/bump-version.yml/dispatches \
-            -d "{\"ref\":\"master\",\"inputs\":{\"version\":\"$TAG\"}}"
+            -d "{\"ref\":\"main\",\"inputs\":{\"version\":\"$TAG\"}}"

.gitignore

@@ -13,6 +13,9 @@ __pycache__/
 # Intellij Idea
 .idea
 
+# Vim
+*.swp
+
 # Hide some OS X stuff
 .DS_Store
 .AppleDouble
@@ -81,7 +84,8 @@ venv.bak/
 .pioenvs
 .piolibdeps
 .pio
-.vscode
+.vscode/
+!.vscode/tasks.json
 CMakeListsPrivate.txt
 CMakeLists.txt
 
@@ -99,6 +103,8 @@ CMakeLists.txt
 
 # CMake
 cmake-build-debug/
+cmake-build-livingroom8266/
+cmake-build-livingroom32/
 cmake-build-release/
 
 CMakeCache.txt
@@ -119,4 +125,5 @@ config/
 tests/build/
 tests/.esphome/
 /.temp-clang-tidy.cpp
-/.idea/
+/.temp/
+.pio/

.pre-commit-config.yaml

@@ -1,11 +1,27 @@
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.4.0
+  - repo: https://github.com/ambv/black
+    rev: 20.8b1
     hooks:
-    -   id: trailing-whitespace
-    -   id: end-of-file-fixer
-    -   id: check-yaml
-    -   id: check-added-large-files
-    -   id: flake8
+    - id: black
+      args:
+        - --safe
+        - --quiet
+      files: ^((esphome|script|tests)/.+)?[^/]+\.py$
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.8.4
+    hooks:
+      - id: flake8
+        additional_dependencies:
+          - flake8-docstrings==1.5.0
+          - pydocstyle==5.1.1
+        files: ^(esphome|tests)/.+\.py$
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: no-commit-to-branch
+        args:
+          - --branch=dev
+          - --branch=release
+          - --branch=beta

.vscode/tasks.json

@@ -0,0 +1,32 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "run",
+      "type": "shell",
+      "command": "python3 -m esphome dashboard config/",
+      "problemMatcher": []
+    },
+    {
+      "label": "clang-tidy",
+      "type": "shell",
+      "command": "./script/clang-tidy",
+      "problemMatcher": [
+        {
+          "owner": "clang-tidy",
+          "fileLocation": "absolute",
+          "pattern": [
+            {
+              "regexp": "^(.*):(\\d+):(\\d+):\\s+(error):\\s+(.*) \\[([a-z0-9,\\-]+)\\]\\s*$",
+              "file": 1,
+              "line": 2,
+              "column": 3,
+              "severity": 4,
+              "message": 5
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

CODEOWNERS

@@ -13,51 +13,138 @@ esphome/core/* @esphome/core
 # Integrations
 esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
+esphome/components/addressable_light/* @justfalter
+esphome/components/am43/* @buxtronix
+esphome/components/am43/cover/* @buxtronix
+esphome/components/animation/* @syndlex
+esphome/components/anova/* @buxtronix
 esphome/components/api/* @OttoWinter
 esphome/components/async_tcp/* @OttoWinter
+esphome/components/atc_mithermometer/* @ahpohl
+esphome/components/b_parasite/* @rbaron
+esphome/components/ballu/* @bazuchan
 esphome/components/bang_bang/* @OttoWinter
 esphome/components/binary_sensor/* @esphome/core
+esphome/components/ble_client/* @buxtronix
+esphome/components/bme680_bsec/* @trvrnrth
+esphome/components/canbus/* @danielschramm @mvturnho
 esphome/components/captive_portal/* @OttoWinter
 esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
+esphome/components/color_temperature/* @jesserockz
 esphome/components/coolix/* @glmnet
 esphome/components/cover/* @esphome/core
+esphome/components/cs5460a/* @balrog-kun
 esphome/components/ct_clamp/* @jesserockz
 esphome/components/debug/* @OttoWinter
 esphome/components/dfplayer/* @glmnet
 esphome/components/dht/* @OttoWinter
+esphome/components/ds1307/* @badbadc0ffee
+esphome/components/dsmr/* @glmnet @zuidwijk
+esphome/components/esp32_ble/* @jesserockz
+esphome/components/esp32_ble_server/* @jesserockz
+esphome/components/esp32_improv/* @jesserockz
 esphome/components/exposure_notifications/* @OttoWinter
+esphome/components/ezo/* @ssieb
 esphome/components/fastled_base/* @OttoWinter
+esphome/components/fingerprint_grow/* @OnFreund @loongyh
 esphome/components/globals/* @esphome/core
 esphome/components/gpio/* @esphome/core
+esphome/components/gps/* @coogle
+esphome/components/havells_solar/* @sourabhjaiswal
+esphome/components/hitachi_ac424/* @sourabhjaiswal
 esphome/components/homeassistant/* @OttoWinter
+esphome/components/hrxl_maxsonar_wr/* @netmikey
 esphome/components/i2c/* @esphome/core
+esphome/components/improv/* @jesserockz
+esphome/components/inkbird_ibsth1_mini/* @fkirill
+esphome/components/inkplate6/* @jesserockz
 esphome/components/integration/* @OttoWinter
 esphome/components/interval/* @esphome/core
 esphome/components/json/* @OttoWinter
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
 esphome/components/logger/* @esphome/core
+esphome/components/max7219digit/* @rspaargaren
+esphome/components/mcp23008/* @jesserockz
+esphome/components/mcp23017/* @jesserockz
+esphome/components/mcp23s08/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23s17/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23x08_base/* @jesserockz
+esphome/components/mcp23x17_base/* @jesserockz
+esphome/components/mcp23xxx_base/* @jesserockz
+esphome/components/mcp2515/* @danielschramm @mvturnho
+esphome/components/mcp9808/* @k7hpn
+esphome/components/midea_ac/* @dudanov
+esphome/components/midea_dongle/* @dudanov
+esphome/components/mitsubishi/* @RubyBailey
 esphome/components/network/* @esphome/core
+esphome/components/nextion/* @senexcrenshaw
+esphome/components/nextion/binary_sensor/* @senexcrenshaw
+esphome/components/nextion/sensor/* @senexcrenshaw
+esphome/components/nextion/switch/* @senexcrenshaw
+esphome/components/nextion/text_sensor/* @senexcrenshaw
+esphome/components/nfc/* @jesserockz
+esphome/components/number/* @esphome/core
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/pid/* @OttoWinter
-esphome/components/pn532/* @OttoWinter
+esphome/components/pipsolar/* @andreashergert1984
+esphome/components/pmsa003i/* @sjtrny
+esphome/components/pn532/* @OttoWinter @jesserockz
+esphome/components/pn532_i2c/* @OttoWinter @jesserockz
+esphome/components/pn532_spi/* @OttoWinter @jesserockz
 esphome/components/power_supply/* @esphome/core
+esphome/components/pulse_meter/* @stevebaxter
+esphome/components/pvvx_mithermometer/* @pasiz
+esphome/components/rc522/* @glmnet
+esphome/components/rc522_i2c/* @glmnet
+esphome/components/rc522_spi/* @glmnet
 esphome/components/restart/* @esphome/core
 esphome/components/rf_bridge/* @jesserockz
+esphome/components/rgbct/* @jesserockz
 esphome/components/rtttl/* @glmnet
 esphome/components/script/* @esphome/core
+esphome/components/sdm_meter/* @jesserockz @polyfaces
+esphome/components/sdp3x/* @Azimath
+esphome/components/selec_meter/* @sourabhjaiswal
+esphome/components/select/* @esphome/core
 esphome/components/sensor/* @esphome/core
+esphome/components/sgp40/* @SenexCrenshaw
+esphome/components/sht4x/* @sjtrny
 esphome/components/shutdown/* @esphome/core
 esphome/components/sim800l/* @glmnet
+esphome/components/sm2135/* @BoukeHaarsma23
 esphome/components/spi/* @esphome/core
+esphome/components/ssd1322_base/* @kbx81
+esphome/components/ssd1322_spi/* @kbx81
+esphome/components/ssd1325_base/* @kbx81
+esphome/components/ssd1325_spi/* @kbx81
+esphome/components/ssd1327_base/* @kbx81
+esphome/components/ssd1327_i2c/* @kbx81
+esphome/components/ssd1327_spi/* @kbx81
+esphome/components/ssd1331_base/* @kbx81
+esphome/components/ssd1331_spi/* @kbx81
+esphome/components/ssd1351_base/* @kbx81
+esphome/components/ssd1351_spi/* @kbx81
+esphome/components/st7735/* @SenexCrenshaw
+esphome/components/st7789v/* @kbx81
 esphome/components/substitutions/* @esphome/core
 esphome/components/sun/* @OttoWinter
 esphome/components/switch/* @esphome/core
+esphome/components/t6615/* @tylermenezes
+esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tcl112/* @glmnet
+esphome/components/teleinfo/* @0hax
+esphome/components/thermostat/* @kbx81
 esphome/components/time/* @OttoWinter
+esphome/components/tlc5947/* @rnauber
 esphome/components/tm1637/* @glmnet
+esphome/components/tmp102/* @timsavage
+esphome/components/tmp117/* @Azimath
+esphome/components/tof10120/* @wstrzalka
+esphome/components/toshiba/* @kbx81
+esphome/components/tsl2591/* @wjcarpenter
 esphome/components/tuya/binary_sensor/* @jesserockz
 esphome/components/tuya/climate/* @jesserockz
 esphome/components/tuya/sensor/* @jesserockz
@@ -67,3 +154,6 @@ esphome/components/ultrasonic/* @OttoWinter
 esphome/components/version/* @esphome/core
 esphome/components/web_server_base/* @OttoWinter
 esphome/components/whirlpool/* @glmnet
+esphome/components/xiaomi_lywsd03mmc/* @ahpohl
+esphome/components/xiaomi_mhoc401/* @vevsvevs
+esphome/components/xpt2046/* @numo68

CODE_OF_CONDUCT.md

@@ -8,19 +8,19 @@ In the interest of fostering an open and welcoming environment, we as contributo
 
 Examples of behavior that contributes to creating a positive environment include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Our Responsibilities
 
@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@otto-winter.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at esphome@nabucasa.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

README.md

@@ -1,4 +1,4 @@
-# ESPHome [![Build Status](https://travis-ci.org/esphome/esphome.svg?branch=master)](https://travis-ci.org/esphome/esphome) [![Discord Chat](https://img.shields.io/discord/429907082951524364.svg)](https://discord.gg/KhAMKrd) [![GitHub release](https://img.shields.io/github/release/esphome/esphome.svg)](https://GitHub.com/esphome/esphome/releases/)
+# ESPHome [![Discord Chat](https://img.shields.io/discord/429907082951524364.svg)](https://discord.gg/KhAMKrd) [![GitHub release](https://img.shields.io/github/release/esphome/esphome.svg)](https://GitHub.com/esphome/esphome/releases/)
 
 [![ESPHome Logo](https://esphome.io/_images/logo-text.png)](https://esphome.io/)
 

docker/Dockerfile

@@ -1,9 +1,11 @@
-ARG BUILD_FROM=esphome/esphome-base-amd64:2.6.0
+ARG BUILD_FROM=esphome/esphome-base:latest
 FROM ${BUILD_FROM}
 
 # First install requirements to leverage caching when requirements don't change
-COPY requirements.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt
+COPY requirements.txt requirements_optional.txt docker/platformio_install_deps.py platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_optional.txt \
+    && /platformio_install_deps.py /platformio.ini
 
 # Then copy esphome and install
 COPY . .
@@ -12,10 +14,17 @@ RUN pip3 install --no-cache-dir -e .
 # Settings for dashboard
 ENV USERNAME="" PASSWORD=""
 
+# Expose the dashboard to Docker
+EXPOSE 6052
+
+# Run healthcheck (heartbeat)
+HEALTHCHECK --interval=30s --timeout=30s \
+  CMD curl --fail http://localhost:6052 || exit 1
+
 # The directory the user should mount their configuration files to
 WORKDIR /config
 # Set entrypoint to esphome so that the user doesn't have to type 'esphome'
 # in every docker command twice
 ENTRYPOINT ["esphome"]
 # When no arguments given, start the dashboard in the workdir
-CMD ["/config", "dashboard"]
+CMD ["dashboard", "/config"]

docker/Dockerfile.dev

@@ -1,13 +1 @@
-FROM esphome/esphome-base-amd64:2.6.0
-
-COPY . .
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        python3-wheel \
-        net-tools \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /workspaces
-ENV SHELL /bin/bash
+FROM esphome/esphome-lint:1.1

docker/Dockerfile.hassio

@@ -1,9 +1,11 @@
-ARG BUILD_FROM
+ARG BUILD_FROM=esphome/esphome-hassio-base:latest
 FROM ${BUILD_FROM}
 
 # First install requirements to leverage caching when requirements don't change
-COPY requirements.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt
+COPY requirements.txt requirements_optional.txt docker/platformio_install_deps.py platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_optional.txt \
+    && /platformio_install_deps.py /platformio.ini
 
 # Copy root filesystem
 COPY docker/rootfs/ /

docker/Dockerfile.lint

@@ -1,7 +1,10 @@
-FROM esphome/esphome-lint-base:2.6.0
+ARG BUILD_FROM=esphome/esphome-lint-base:latest
+FROM ${BUILD_FROM}
 
-COPY requirements.txt requirements_test.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt -r /requirements_test.txt
+COPY requirements.txt requirements_optional.txt requirements_test.txt docker/platformio_install_deps.py  platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_optional.txt -r /requirements_test.txt \
+    && /platformio_install_deps.py /platformio.ini
 
 VOLUME ["/esphome"]
 WORKDIR /esphome

docker/build.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+from dataclasses import dataclass
+import subprocess
+import argparse
+import platform
+import shlex
+import re
+import sys
+
+
+CHANNEL_DEV = 'dev'
+CHANNEL_BETA = 'beta'
+CHANNEL_RELEASE = 'release'
+CHANNELS = [CHANNEL_DEV, CHANNEL_BETA, CHANNEL_RELEASE]
+
+ARCH_AMD64 = 'amd64'
+ARCH_ARMV7 = 'armv7'
+ARCH_AARCH64 = 'aarch64'
+ARCHS = [ARCH_AMD64, ARCH_ARMV7, ARCH_AARCH64]
+
+TYPE_DOCKER = 'docker'
+TYPE_HA_ADDON = 'ha-addon'
+TYPE_LINT = 'lint'
+TYPES = [TYPE_DOCKER, TYPE_HA_ADDON, TYPE_LINT]
+
+
+BASE_VERSION = "3.6.0"
+
+
+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("--arch", choices=ARCHS, required=False, help="The architecture to build for")
+parser.add_argument("--build-type", choices=TYPES, required=True, help="The type of build to run")
+parser.add_argument("--dry-run", action="store_true", help="Don't run any commands, just print them")
+subparsers = parser.add_subparsers(help="Action to perform", dest="command", required=True)
+build_parser = subparsers.add_parser("build", help="Build the image")
+push_parser = subparsers.add_parser("push", help="Tag the already built image and push it to docker hub")
+manifest_parser = subparsers.add_parser("manifest", help="Create a manifest from already pushed images")
+
+
+
+# only lists some possibilities, doesn't have to be perfect
+# https://stackoverflow.com/a/45125525
+UNAME_TO_ARCH = {
+    "x86_64": ARCH_AMD64,
+    "aarch64": ARCH_AARCH64,
+    "aarch64_be": ARCH_AARCH64,
+    "arm": ARCH_ARMV7,
+}
+
+
+@dataclass(frozen=True)
+class DockerParams:
+    build_from: str
+    build_to: str
+    manifest_to: str
+    dockerfile: str
+
+    @classmethod
+    def for_type_arch(cls, build_type, arch):
+        prefix = {
+            TYPE_DOCKER: "esphome/esphome",
+            TYPE_HA_ADDON: "esphome/esphome-hassio",
+            TYPE_LINT: "esphome/esphome-lint"
+        }[build_type]
+        build_from = f"ghcr.io/{prefix}-base-{arch}:{BASE_VERSION}"
+        build_to = f"{prefix}-{arch}"
+        dockerfile = {
+            TYPE_DOCKER: "docker/Dockerfile",
+            TYPE_HA_ADDON: "docker/Dockerfile.hassio",
+            TYPE_LINT: "docker/Dockerfile.lint",
+        }[build_type]
+        return cls(
+            build_from=build_from,
+            build_to=build_to,
+            manifest_to=prefix,
+            dockerfile=dockerfile
+        )
+
+
+def main():
+    args = parser.parse_args()
+
+    def run_command(*cmd, ignore_error: bool = False):
+        print(f"$ {shlex.join(list(cmd))}")
+        if not args.dry_run:
+            rc = subprocess.call(list(cmd))
+            if rc != 0 and not ignore_error:
+                print("Command failed")
+                sys.exit(1)
+
+    # detect channel from tag
+    match = re.match(r'^\d+\.\d+(?:\.\d+)?(b\d+)?$', args.tag)
+    if match is None:
+        channel = CHANNEL_DEV
+    elif match.group(1) is None:
+        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 args.command == "build":
+        # 1. pull cache image
+        params = DockerParams.for_type_arch(args.build_type, args.arch)
+        cache_tag = {
+            CHANNEL_DEV: "dev",
+            CHANNEL_BETA: "beta",
+            CHANNEL_RELEASE: "latest",
+        }[channel]
+        cache_img = f"ghcr.io/{params.build_to}:{cache_tag}"
+        run_command("docker", "pull", cache_img, ignore_error=True)
+
+        # 2. register QEMU binfmt (if not host arch)
+        is_native = UNAME_TO_ARCH.get(platform.machine()) == args.arch
+        if not is_native:
+            run_command(
+                "docker", "run", "--rm", "--privileged", "multiarch/qemu-user-static:5.2.0-2",
+                "--reset", "-p", "yes"
+            )
+
+        # 3. build
+        run_command(
+            "docker", "build",
+            "--build-arg", f"BUILD_FROM={params.build_from}",
+            "--build-arg", f"BUILD_VERSION={args.tag}",
+            "--tag", f"{params.build_to}:{args.tag}",
+            "--cache-from", cache_img,
+            "--file", params.dockerfile,
+            "."
+        )
+    elif args.command == "push":
+        params = DockerParams.for_type_arch(args.build_type, args.arch)
+        imgs = [f"{params.build_to}:{tag}" for tag in tags_to_push]
+        imgs += [f"ghcr.io/{params.build_to}:{tag}" for tag in tags_to_push]
+        src = imgs[0]
+        # 1. tag images
+        for img in imgs[1:]:
+            run_command(
+                "docker", "tag", src, img
+            )
+        # 2. push images
+        for img in imgs:
+            run_command(
+                "docker", "push", img
+            )
+    elif args.command == "manifest":
+        manifest = DockerParams.for_type_arch(args.build_type, ARCH_AMD64).manifest_to
+
+        targets = [f"{manifest}:{tag}" for tag in tags_to_push]
+        targets += [f"ghcr.io/{manifest}:{tag}" for tag in tags_to_push]
+        # 1. Create manifests
+        for target in targets:
+            cmd = ["docker", "manifest", "create", target]
+            for arch in ARCHS:
+                src = f"{DockerParams.for_type_arch(args.build_type, arch).build_to}:{args.tag}"
+                if target.startswith("ghcr.io"):
+                    src = f"ghcr.io/{src}"
+                cmd.append(src)
+            run_command(*cmd)
+        # 2. Push manifests
+        for target in targets:
+            run_command(
+                "docker", "manifest", "push", target
+            )
+
+
+if __name__ == "__main__":
+    main()

docker/platformio_install_deps.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+# This script is used in the docker containers to preinstall
+# all platformio libraries in the global storage
+
+import configparser
+import re
+import subprocess
+import sys
+
+config = configparser.ConfigParser()
+config.read(sys.argv[1])
+libs = []
+for line in config['common']['lib_deps'].splitlines():
+    # Format: '1655@1.0.2  ; TinyGPSPlus (has name conflict)' (includes comment)
+    m = re.search(r'([a-zA-Z0-9-_/]+@[0-9\.]+)', line)
+    if m is None:
+        continue
+    libs.append(m.group(1))
+
+subprocess.check_call(['platformio', 'lib', '-g', 'install', *libs])

docker/rootfs/etc/cont-init.d/30-esphome.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/with-contenv bashio
-# ==============================================================================
-# Community Hass.io Add-ons: ESPHome
-# This files installs the user ESPHome version if specified
-# ==============================================================================
-
-declare esphome_version
-
-if bashio::config.has_value 'esphome_version'; then
-    esphome_version=$(bashio::config 'esphome_version')
-    if [[ $esphome_version == *":"* ]]; then
-      IFS=':' read -r -a array <<< "$esphome_version"
-      username=${array[0]}
-      ref=${array[1]}
-    else
-      username="esphome"
-      ref=$esphome_version
-    fi
-    full_url="https://github.com/${username}/esphome/archive/${ref}.zip"
-    bashio::log.info "Installing esphome version '${esphome_version}' (${full_url})..."
-    pip3 install -U --no-cache-dir "${full_url}" \
-      || bashio::exit.nok "Failed installing esphome pinned version."
-fi

docker/rootfs/etc/cont-init.d/40-migrate.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/with-contenv bashio
-# ==============================================================================
-# Community Hass.io Add-ons: ESPHome
-# This files migrates the esphome config directory from the old path
-# ==============================================================================
-
-if [[ ! -d /config/esphome && -d /config/esphomeyaml ]]; then
-    echo "Moving config directory from /config/esphomeyaml to /config/esphome"
-    mv /config/esphomeyaml /config/esphome
-    mv /config/esphome/.esphomeyaml /config/esphome/.esphome
-fi

docker/rootfs/etc/services.d/esphome/run

@@ -23,4 +23,4 @@ if bashio::config.has_value 'relative_url'; then
 fi
 
 bashio::log.info "Starting ESPHome dashboard..."
-exec esphome /config/esphome dashboard --socket /var/run/esphome.sock --hassio
+exec esphome dashboard /config/esphome --socket /var/run/esphome.sock --hassio

esphome/__main__.py

@@ -8,21 +8,38 @@ from datetime import datetime
 from esphome import const, writer, yaml_util
 import esphome.codegen as cg
 from esphome.config import iter_components, read_config, strip_default_ids
-from esphome.const import CONF_BAUD_RATE, CONF_BROKER, CONF_LOGGER, CONF_OTA, \
-    CONF_PASSWORD, CONF_PORT, CONF_ESPHOME, CONF_PLATFORMIO_OPTIONS
-from esphome.core import CORE, EsphomeError, coroutine, coroutine_with_priority
-from esphome.helpers import color, indent
-from esphome.util import run_external_command, run_external_process, safe_print, list_yaml_files, \
-    get_serial_ports
+from esphome.const import (
+    CONF_BAUD_RATE,
+    CONF_BROKER,
+    CONF_DEASSERT_RTS_DTR,
+    CONF_LOGGER,
+    CONF_OTA,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_ESPHOME,
+    CONF_PLATFORMIO_OPTIONS,
+)
+from esphome.core import CORE, EsphomeError, coroutine
+from esphome.helpers import indent
+from esphome.util import (
+    run_external_command,
+    run_external_process,
+    safe_print,
+    list_yaml_files,
+    get_serial_ports,
+)
+from esphome.log import color, setup_log, Fore
 
 _LOGGER = logging.getLogger(__name__)
 
 
 def choose_prompt(options):
     if not options:
-        raise EsphomeError("Found no valid options for upload/logging, please make sure relevant "
-                           "sections (ota, api, mqtt, ...) are in your configuration and/or the "
-                           "device is plugged in.")
+        raise EsphomeError(
+            "Found no valid options for upload/logging, please make sure relevant "
+            "sections (ota, api, mqtt, ...) are in your configuration and/or the "
+            "device is plugged in."
+        )
 
     if len(options) == 1:
         return options[0][1]
@@ -32,7 +49,7 @@ def choose_prompt(options):
         safe_print(f"  [{i+1}] {desc}")
 
     while True:
-        opt = input('(number): ')
+        opt = input("(number): ")
         if opt in options:
             opt = options.index(opt)
             break
@@ -42,7 +59,7 @@ def choose_prompt(options):
                 raise ValueError
             break
         except ValueError:
-            safe_print(color('red', f"Invalid option: '{opt}'"))
+            safe_print(color(Fore.RED, f"Invalid option: '{opt}'"))
     return options[opt - 1][1]
 
 
@@ -50,14 +67,14 @@ def choose_upload_log_host(default, check_default, show_ota, show_mqtt, show_api
     options = []
     for port in get_serial_ports():
         options.append((f"{port.path} ({port.description})", port.path))
-    if (show_ota and 'ota' in CORE.config) or (show_api and 'api' in CORE.config):
+    if (show_ota and "ota" in CORE.config) or (show_api and "api" in CORE.config):
         options.append((f"Over The Air ({CORE.address})", CORE.address))
-        if default == 'OTA':
+        if default == "OTA":
             return CORE.address
-    if show_mqtt and 'mqtt' in CORE.config:
-        options.append(("MQTT ({})".format(CORE.config['mqtt'][CONF_BROKER]), 'MQTT'))
-        if default == 'OTA':
-            return 'MQTT'
+    if show_mqtt and "mqtt" in CORE.config:
+        options.append(("MQTT ({})".format(CORE.config["mqtt"][CONF_BROKER]), "MQTT"))
+        if default == "OTA":
+            return "MQTT"
     if default is not None:
         return default
     if check_default is not None and check_default in [opt[1] for opt in options]:
@@ -66,11 +83,11 @@ def choose_upload_log_host(default, check_default, show_ota, show_mqtt, show_api
 
 
 def get_port_type(port):
-    if port.startswith('/') or port.startswith('COM'):
-        return 'SERIAL'
-    if port == 'MQTT':
-        return 'MQTT'
-    return 'NETWORK'
+    if port.startswith("/") or port.startswith("COM"):
+        return "SERIAL"
+    if port == "MQTT":
+        return "MQTT"
+    return "NETWORK"
 
 
 def run_miniterm(config, port):
@@ -80,41 +97,58 @@ def run_miniterm(config, port):
     if CONF_LOGGER not in config:
         _LOGGER.info("Logger is not enabled. Not starting UART logs.")
         return
-    baud_rate = config['logger'][CONF_BAUD_RATE]
+    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
     _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
 
     backtrace_state = False
-    with serial.Serial(port, baudrate=baud_rate) as ser:
+    ser = serial.Serial()
+    ser.baudrate = baud_rate
+    ser.port = port
+
+    # We can't set to False by default since it leads to toggling and hence
+    # ESP32 resets on some platforms.
+    if config["logger"][CONF_DEASSERT_RTS_DTR]:
+        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]')
+            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)
 
             backtrace_state = platformio_api.process_stacktrace(
-                config, line, backtrace_state=backtrace_state)
+                config, line, backtrace_state=backtrace_state
+            )
 
 
 def wrap_to_code(name, comp):
     coro = coroutine(comp.to_code)
 
     @functools.wraps(comp.to_code)
-    @coroutine_with_priority(coro.priority)
-    def wrapped(conf):
+    async def wrapped(conf):
         cg.add(cg.LineComment(f"{name}:"))
         if comp.config_schema is not None:
             conf_str = yaml_util.dump(conf)
-            conf_str = conf_str.replace('//', '')
+            conf_str = conf_str.replace("//", "")
             cg.add(cg.LineComment(indent(conf_str)))
-        yield coro(conf)
+        await coro(conf)
 
+    if hasattr(coro, "priority"):
+        wrapped.priority = coro.priority
     return wrapped
 
 
@@ -151,15 +185,31 @@ def compile_program(args, config):
 
 def upload_using_esptool(config, port):
     path = CORE.firmware_bin
-    first_baudrate = config[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS].get('upload_speed', 460800)
+    first_baudrate = config[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS].get(
+        "upload_speed", 460800
+    )
 
     def run_esptool(baud_rate):
-        cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
-               '--baud', str(baud_rate),
-               '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
+        cmd = [
+            "esptool.py",
+            "--before",
+            "default_reset",
+            "--after",
+            "hard_reset",
+            "--baud",
+            str(baud_rate),
+            "--chip",
+            "esp8266",
+            "--port",
+            port,
+            "write_flash",
+            "0x0",
+            path,
+        ]
 
-        if os.environ.get('ESPHOME_USE_SUBPROCESS') is None:
+        if os.environ.get("ESPHOME_USE_SUBPROCESS") is None:
             import esptool
+
             # pylint: disable=protected-access
             return run_external_command(esptool._main, *cmd)
 
@@ -169,14 +219,16 @@ def upload_using_esptool(config, port):
     if rc == 0 or first_baudrate == 115200:
         return rc
     # Try with 115200 baud rate, with some serial chips the faster baud rates do not work well
-    _LOGGER.info("Upload with baud rate %s failed. Trying again with baud rate 115200.",
-                 first_baudrate)
+    _LOGGER.info(
+        "Upload with baud rate %s failed. Trying again with baud rate 115200.",
+        first_baudrate,
+    )
     return run_esptool(115200)
 
 
 def upload_program(config, args, host):
     # if upload is to a serial port use platformio, otherwise assume ota
-    if get_port_type(host) == 'SERIAL':
+    if get_port_type(host) == "SERIAL":
         from esphome import platformio_api
 
         if CORE.is_esp8266:
@@ -186,8 +238,10 @@ def upload_program(config, args, host):
     from esphome import espota2
 
     if CONF_OTA not in config:
-        raise EsphomeError("Cannot upload Over the Air as the config does not include the ota: "
-                           "component")
+        raise EsphomeError(
+            "Cannot upload Over the Air as the config does not include the ota: "
+            "component"
+        )
 
     ota_conf = config[CONF_OTA]
     remote_port = ota_conf[CONF_PORT]
@@ -196,19 +250,21 @@ def upload_program(config, args, host):
 
 
 def show_logs(config, args, port):
-    if 'logger' not in config:
+    if "logger" not in config:
         raise EsphomeError("Logger is not configured!")
-    if get_port_type(port) == 'SERIAL':
+    if get_port_type(port) == "SERIAL":
         run_miniterm(config, port)
         return 0
-    if get_port_type(port) == 'NETWORK' and 'api' in config:
+    if get_port_type(port) == "NETWORK" and "api" in config:
         from esphome.api.client import run_logs
 
         return run_logs(config, port)
-    if get_port_type(port) == 'MQTT' and 'mqtt' in config:
+    if get_port_type(port) == "MQTT" and "mqtt" in config:
         from esphome import mqtt
 
-        return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+        return mqtt.show_logs(
+            config, args.topic, args.username, args.password, args.client_id
+        )
 
     raise EsphomeError("No remote or local logging method configured (api/mqtt/logger)")
 
@@ -216,46 +272,15 @@ def show_logs(config, args, port):
 def clean_mqtt(config, args):
     from esphome import mqtt
 
-    return mqtt.clear_topic(config, args.topic, args.username, args.password, args.client_id)
-
-
-def setup_log(debug=False, quiet=False):
-    if debug:
-        log_level = logging.DEBUG
-        CORE.verbose = True
-    elif quiet:
-        log_level = logging.CRITICAL
-    else:
-        log_level = logging.INFO
-    logging.basicConfig(level=log_level)
-    fmt = "%(levelname)s %(message)s"
-    colorfmt = f"%(log_color)s{fmt}%(reset)s"
-    datefmt = '%H:%M:%S'
-
-    logging.getLogger('urllib3').setLevel(logging.WARNING)
-
-    try:
-        from colorlog import ColoredFormatter
-        logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
-            colorfmt,
-            datefmt=datefmt,
-            reset=True,
-            log_colors={
-                'DEBUG': 'cyan',
-                'INFO': 'green',
-                'WARNING': 'yellow',
-                'ERROR': 'red',
-                'CRITICAL': 'red',
-            }
-        ))
-    except ImportError:
-        pass
+    return mqtt.clear_topic(
+        config, args.topic, args.username, args.password, args.client_id
+    )
 
 
 def command_wizard(args):
     from esphome import wizard
 
-    return wizard.wizard(args.configuration[0])
+    return wizard.wizard(args.configuration)
 
 
 def command_config(args, config):
@@ -269,7 +294,8 @@ def command_config(args, config):
 def command_vscode(args):
     from esphome import vscode
 
-    CORE.config_path = args.configuration[0]
+    logging.disable(logging.INFO)
+    logging.disable(logging.WARNING)
     vscode.read_config(args)
 
 
@@ -288,8 +314,13 @@ def command_compile(args, config):
 
 
 def command_upload(args, config):
-    port = choose_upload_log_host(default=args.upload_port, check_default=None,
-                                  show_ota=True, show_mqtt=False, show_api=False)
+    port = choose_upload_log_host(
+        default=args.device,
+        check_default=None,
+        show_ota=True,
+        show_mqtt=False,
+        show_api=False,
+    )
     exit_code = upload_program(config, args, port)
     if exit_code != 0:
         return exit_code
@@ -298,8 +329,13 @@ def command_upload(args, config):
 
 
 def command_logs(args, config):
-    port = choose_upload_log_host(default=args.serial_port, check_default=None,
-                                  show_ota=False, show_mqtt=True, show_api=True)
+    port = choose_upload_log_host(
+        default=args.device,
+        check_default=None,
+        show_ota=False,
+        show_mqtt=True,
+        show_api=True,
+    )
     return show_logs(config, args, port)
 
 
@@ -311,16 +347,26 @@ def command_run(args, config):
     if exit_code != 0:
         return exit_code
     _LOGGER.info("Successfully compiled program.")
-    port = choose_upload_log_host(default=args.upload_port, check_default=None,
-                                  show_ota=True, show_mqtt=False, show_api=True)
+    port = choose_upload_log_host(
+        default=args.device,
+        check_default=None,
+        show_ota=True,
+        show_mqtt=False,
+        show_api=True,
+    )
     exit_code = upload_program(config, args, port)
     if exit_code != 0:
         return exit_code
     _LOGGER.info("Successfully uploaded program.")
     if args.no_logs:
         return 0
-    port = choose_upload_log_host(default=args.upload_port, check_default=port,
-                                  show_ota=False, show_mqtt=True, show_api=True)
+    port = choose_upload_log_host(
+        default=args.device,
+        check_default=port,
+        show_ota=False,
+        show_mqtt=True,
+        show_api=True,
+    )
     return show_logs(config, args, port)
 
 
@@ -359,7 +405,7 @@ def command_update_all(args):
     import click
 
     success = {}
-    files = list_yaml_files(args.configuration[0])
+    files = list_yaml_files(args.configuration)
     twidth = 60
 
     def print_bar(middle_text):
@@ -369,137 +415,291 @@ def command_update_all(args):
         click.echo(f"{half_line}{middle_text}{half_line}")
 
     for f in files:
-        print("Updating {}".format(color('cyan', f)))
-        print('-' * twidth)
+        print("Updating {}".format(color(Fore.CYAN, f)))
+        print("-" * twidth)
         print()
-        rc = run_external_process('esphome', '--dashboard', f, 'run', '--no-logs', '--upload-port',
-                                  'OTA')
+        rc = run_external_process(
+            "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
+        )
         if rc == 0:
-            print_bar("[{}] {}".format(color('bold_green', 'SUCCESS'), f))
+            print_bar("[{}] {}".format(color(Fore.BOLD_GREEN, "SUCCESS"), f))
             success[f] = True
         else:
-            print_bar("[{}] {}".format(color('bold_red', 'ERROR'), f))
+            print_bar("[{}] {}".format(color(Fore.BOLD_RED, "ERROR"), f))
             success[f] = False
 
         print()
         print()
         print()
 
-    print_bar('[{}]'.format(color('bold_white', 'SUMMARY')))
+    print_bar("[{}]".format(color(Fore.BOLD_WHITE, "SUMMARY")))
     failed = 0
     for f in files:
         if success[f]:
-            print("  - {}: {}".format(f, color('green', 'SUCCESS')))
+            print("  - {}: {}".format(f, color(Fore.GREEN, "SUCCESS")))
         else:
-            print("  - {}: {}".format(f, color('bold_red', 'FAILED')))
+            print("  - {}: {}".format(f, color(Fore.BOLD_RED, "FAILED")))
             failed += 1
     return failed
 
 
 PRE_CONFIG_ACTIONS = {
-    'wizard': command_wizard,
-    'version': command_version,
-    'dashboard': command_dashboard,
-    'vscode': command_vscode,
-    'update-all': command_update_all,
+    "wizard": command_wizard,
+    "version": command_version,
+    "dashboard": command_dashboard,
+    "vscode": command_vscode,
+    "update-all": command_update_all,
 }
 
 POST_CONFIG_ACTIONS = {
-    'config': command_config,
-    'compile': command_compile,
-    'upload': command_upload,
-    'logs': command_logs,
-    'run': command_run,
-    'clean-mqtt': command_clean_mqtt,
-    'mqtt-fingerprint': command_mqtt_fingerprint,
-    'clean': command_clean,
+    "config": command_config,
+    "compile": command_compile,
+    "upload": command_upload,
+    "logs": command_logs,
+    "run": command_run,
+    "clean-mqtt": command_clean_mqtt,
+    "mqtt-fingerprint": command_mqtt_fingerprint,
+    "clean": command_clean,
 }
 
 
 def parse_args(argv):
-    parser = argparse.ArgumentParser(description=f'ESPHome v{const.__version__}')
-    parser.add_argument('-v', '--verbose', help="Enable verbose esphome logs.",
-                        action='store_true')
-    parser.add_argument('-q', '--quiet', help="Disable all esphome logs.",
-                        action='store_true')
-    parser.add_argument('--dashboard', help=argparse.SUPPRESS, action='store_true')
-    parser.add_argument('-s', '--substitution', nargs=2, action='append',
-                        help='Add a substitution', metavar=('key', 'value'))
-    parser.add_argument('configuration', help='Your YAML configuration file.', nargs='*')
+    options_parser = argparse.ArgumentParser(add_help=False)
+    options_parser.add_argument(
+        "-v", "--verbose", help="Enable verbose ESPHome logs.", action="store_true"
+    )
+    options_parser.add_argument(
+        "-q", "--quiet", help="Disable all ESPHome logs.", action="store_true"
+    )
+    options_parser.add_argument(
+        "--dashboard", help=argparse.SUPPRESS, action="store_true"
+    )
+    options_parser.add_argument(
+        "-s",
+        "--substitution",
+        nargs=2,
+        action="append",
+        help="Add a substitution",
+        metavar=("key", "value"),
+    )
 
-    subparsers = parser.add_subparsers(help='Commands', dest='command')
+    # Keep backward compatibility with the old command line format of
+    # esphome <config> <command>.
+    #
+    # Unfortunately this can't be done by adding another configuration argument to the
+    # main config parser, as argparse is greedy when parsing arguments, so in regular
+    # usage it'll eat the command as the configuration argument and error out out
+    # because it can't parse the configuration as a command.
+    #
+    # Instead, construct an ad-hoc parser for the old format that doesn't actually
+    # process the arguments, but parses them enough to let us figure out if the old
+    # format is used. In that case, swap the command and configuration in the arguments
+    # and continue on with the normal parser (after raising a deprecation warning).
+    #
+    # Disable argparse's built-in help option and add it manually to prevent this
+    # parser from printing the help messagefor the old format when invoked with -h.
+    compat_parser = argparse.ArgumentParser(parents=[options_parser], add_help=False)
+    compat_parser.add_argument("-h", "--help")
+    compat_parser.add_argument("configuration", nargs="*")
+    compat_parser.add_argument(
+        "command",
+        choices=[
+            "config",
+            "compile",
+            "upload",
+            "logs",
+            "run",
+            "clean-mqtt",
+            "wizard",
+            "mqtt-fingerprint",
+            "version",
+            "clean",
+            "dashboard",
+            "vscode",
+            "update-all",
+        ],
+    )
+
+    # on Python 3.9+ we can simply set exit_on_error=False in the constructor
+    def _raise(x):
+        raise argparse.ArgumentError(None, x)
+
+    compat_parser.error = _raise
+
+    deprecated_argv_suggestion = None
+
+    if ["dashboard", "config"] == argv[1:3] or ["version"] == argv[1:2]:
+        # this is most likely meant in new-style arg format. do not try compat parsing
+        pass
+    else:
+        try:
+            result, unparsed = compat_parser.parse_known_args(argv[1:])
+            last_option = len(argv) - len(unparsed) - 1 - len(result.configuration)
+            unparsed = [
+                "--device" if arg in ("--upload-port", "--serial-port") else arg
+                for arg in unparsed
+            ]
+            argv = (
+                argv[0:last_option] + [result.command] + result.configuration + unparsed
+            )
+            deprecated_argv_suggestion = argv
+        except argparse.ArgumentError:
+            # This is not an old-style command line, so we don't have to do anything.
+            pass
+
+    # And continue on with regular parsing
+    parser = argparse.ArgumentParser(
+        description=f"ESPHome v{const.__version__}", parents=[options_parser]
+    )
+    parser.set_defaults(deprecated_argv_suggestion=deprecated_argv_suggestion)
+
+    mqtt_options = argparse.ArgumentParser(add_help=False)
+    mqtt_options.add_argument("--topic", help="Manually set the MQTT topic.")
+    mqtt_options.add_argument("--username", help="Manually set the MQTT username.")
+    mqtt_options.add_argument("--password", help="Manually set the MQTT password.")
+    mqtt_options.add_argument("--client-id", help="Manually set the MQTT client id.")
+
+    subparsers = parser.add_subparsers(
+        help="Command to run:", dest="command", metavar="command"
+    )
     subparsers.required = True
-    subparsers.add_parser('config', help='Validate the configuration and spit it out.')
 
-    parser_compile = subparsers.add_parser('compile',
-                                           help='Read the configuration and compile a program.')
-    parser_compile.add_argument('--only-generate',
-                                help="Only generate source code, do not compile.",
-                                action='store_true')
+    parser_config = subparsers.add_parser(
+        "config", help="Validate the configuration and spit it out."
+    )
+    parser_config.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    parser_upload = subparsers.add_parser('upload', help='Validate the configuration '
-                                                         'and upload the latest binary.')
-    parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
-                                                     "For example /dev/cu.SLAB_USBtoUART.")
+    parser_compile = subparsers.add_parser(
+        "compile", help="Read the configuration and compile a program."
+    )
+    parser_compile.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_compile.add_argument(
+        "--only-generate",
+        help="Only generate source code, do not compile.",
+        action="store_true",
+    )
 
-    parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
-                                                     'and show all MQTT logs.')
-    parser_logs.add_argument('--topic', help='Manually set the topic to subscribe to.')
-    parser_logs.add_argument('--username', help='Manually set the username.')
-    parser_logs.add_argument('--password', help='Manually set the password.')
-    parser_logs.add_argument('--client-id', help='Manually set the client id.')
-    parser_logs.add_argument('--serial-port', help="Manually specify a serial port to use"
-                                                   "For example /dev/cu.SLAB_USBtoUART.")
+    parser_upload = subparsers.add_parser(
+        "upload", help="Validate the configuration and upload the latest binary."
+    )
+    parser_upload.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_upload.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
 
-    parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
-                                                   'upload it, and start MQTT logs.')
-    parser_run.add_argument('--upload-port', help="Manually specify the upload port/ip to use. "
-                                                  "For example /dev/cu.SLAB_USBtoUART.")
-    parser_run.add_argument('--no-logs', help='Disable starting MQTT logs.',
-                            action='store_true')
-    parser_run.add_argument('--topic', help='Manually set the topic to subscribe to for logs.')
-    parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
-    parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
-    parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
+    parser_logs = subparsers.add_parser(
+        "logs",
+        help="Validate the configuration and show all logs.",
+        parents=[mqtt_options],
+    )
+    parser_logs.add_argument(
+        "configuration", help="Your YAML configuration file.", nargs=1
+    )
+    parser_logs.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
 
-    parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
-                                                            "retain messages.")
-    parser_clean.add_argument('--topic', help='Manually set the topic to subscribe to.')
-    parser_clean.add_argument('--username', help='Manually set the username.')
-    parser_clean.add_argument('--password', help='Manually set the password.')
-    parser_clean.add_argument('--client-id', help='Manually set the client id.')
+    parser_run = subparsers.add_parser(
+        "run",
+        help="Validate the configuration, create a binary, upload it, and start logs.",
+        parents=[mqtt_options],
+    )
+    parser_run.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_run.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
+    parser_run.add_argument(
+        "--no-logs", help="Disable starting logs.", action="store_true"
+    )
 
-    subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
-                                         "you through setting up esphome.")
+    parser_clean = subparsers.add_parser(
+        "clean-mqtt",
+        help="Helper to clear retained messages from an MQTT topic.",
+        parents=[mqtt_options],
+    )
+    parser_clean.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
+    parser_wizard = subparsers.add_parser(
+        "wizard",
+        help="A helpful setup wizard that will guide you through setting up ESPHome.",
+    )
+    parser_wizard.add_argument(
+        "configuration",
+        help="Your YAML configuration file.",
+    )
 
-    subparsers.add_parser('version', help="Print the esphome version and exit.")
+    parser_fingerprint = subparsers.add_parser(
+        "mqtt-fingerprint", help="Get the SSL fingerprint from a MQTT broker."
+    )
+    parser_fingerprint.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    subparsers.add_parser('clean', help="Delete all temporary build files.")
+    subparsers.add_parser("version", help="Print the ESPHome version and exit.")
 
-    dashboard = subparsers.add_parser('dashboard',
-                                      help="Create a simple web server for a dashboard.")
-    dashboard.add_argument("--port", help="The HTTP port to open connections on. Defaults to 6052.",
-                           type=int, default=6052)
-    dashboard.add_argument("--username", help="The optional username to require "
-                                              "for authentication.",
-                           type=str, default='')
-    dashboard.add_argument("--password", help="The optional password to require "
-                                              "for authentication.",
-                           type=str, default='')
-    dashboard.add_argument("--open-ui", help="Open the dashboard UI in a browser.",
-                           action='store_true')
-    dashboard.add_argument("--hassio",
-                           help=argparse.SUPPRESS,
-                           action="store_true")
-    dashboard.add_argument("--socket",
-                           help="Make the dashboard serve under a unix socket", type=str)
+    parser_clean = subparsers.add_parser(
+        "clean", help="Delete all temporary build files."
+    )
+    parser_clean.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    vscode = subparsers.add_parser('vscode', help=argparse.SUPPRESS)
-    vscode.add_argument('--ace', action='store_true')
+    parser_dashboard = subparsers.add_parser(
+        "dashboard", help="Create a simple web server for a dashboard."
+    )
+    parser_dashboard.add_argument(
+        "configuration",
+        help="Your YAML configuration file directory.",
+    )
+    parser_dashboard.add_argument(
+        "--port",
+        help="The HTTP port to open connections on. Defaults to 6052.",
+        type=int,
+        default=6052,
+    )
+    parser_dashboard.add_argument(
+        "--username",
+        help="The optional username to require for authentication.",
+        type=str,
+        default="",
+    )
+    parser_dashboard.add_argument(
+        "--password",
+        help="The optional password to require for authentication.",
+        type=str,
+        default="",
+    )
+    parser_dashboard.add_argument(
+        "--open-ui", help="Open the dashboard UI in a browser.", action="store_true"
+    )
+    parser_dashboard.add_argument(
+        "--hassio", help=argparse.SUPPRESS, action="store_true"
+    )
+    parser_dashboard.add_argument(
+        "--socket", help="Make the dashboard serve under a unix socket", type=str
+    )
 
-    subparsers.add_parser('update-all', help=argparse.SUPPRESS)
+    parser_vscode = subparsers.add_parser("vscode")
+    parser_vscode.add_argument("configuration", help="Your YAML configuration file.")
+    parser_vscode.add_argument("--ace", action="store_true")
+
+    parser_update = subparsers.add_parser("update-all")
+    parser_update.add_argument(
+        "configuration", help="Your YAML configuration file directories.", nargs="+"
+    )
 
     return parser.parse_args(argv[1:])
 
@@ -509,20 +709,26 @@ def run_esphome(argv):
     CORE.dashboard = args.dashboard
 
     setup_log(args.verbose, args.quiet)
-    if args.command != 'version' and not args.configuration:
-        _LOGGER.error("Missing configuration parameter, see esphome --help.")
-        return 1
+    if args.deprecated_argv_suggestion is not None and args.command != "vscode":
+        _LOGGER.warning(
+            "Calling ESPHome with the configuration before the command is deprecated "
+            "and will be removed in the future. "
+        )
+        _LOGGER.warning("Please instead use:")
+        _LOGGER.warning("   esphome %s", " ".join(args.deprecated_argv_suggestion[1:]))
 
-    if sys.version_info < (3, 6, 0):
-        _LOGGER.error("You're running ESPHome with Python <3.6. ESPHome is no longer compatible "
-                      "with this Python version. Please reinstall ESPHome with Python 3.6+")
+    if sys.version_info < (3, 7, 0):
+        _LOGGER.error(
+            "You're running ESPHome with Python <3.7. ESPHome is no longer compatible "
+            "with this Python version. Please reinstall ESPHome with Python 3.7+"
+        )
         return 1
 
     if args.command in PRE_CONFIG_ACTIONS:
         try:
             return PRE_CONFIG_ACTIONS[args.command](args)
         except EsphomeError as e:
-            _LOGGER.error(e)
+            _LOGGER.error(e, exc_info=args.verbose)
             return 1
 
     for conf_path in args.configuration:
@@ -540,7 +746,7 @@ def run_esphome(argv):
         try:
             rc = POST_CONFIG_ACTIONS[args.command](args, config)
         except EsphomeError as e:
-            _LOGGER.error(e)
+            _LOGGER.error(e, exc_info=args.verbose)
             return 1
         if rc != 0:
             return rc

esphome/api/client.py

@@ -13,7 +13,8 @@ from esphome import const
 import esphome.api.api_pb2 as pb
 from esphome.const import CONF_PASSWORD, CONF_PORT
 from esphome.core import EsphomeError
-from esphome.helpers import resolve_ip_address, indent, color
+from esphome.helpers import resolve_ip_address, indent
+from esphome.log import color, Fore
 from esphome.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
@@ -177,11 +178,15 @@ class APIClient(threading.Thread):
         try:
             ip = resolve_ip_address(self._address)
         except EsphomeError as err:
-            _LOGGER.warning("Error resolving IP address of %s. Is it connected to WiFi?",
-                            self._address)
-            _LOGGER.warning("(If this error persists, please set a static IP address: "
-                            "https://esphome.io/components/wifi.html#manual-ips)")
-            raise APIConnectionError(err)
+            _LOGGER.warning(
+                "Error resolving IP address of %s. Is it connected to WiFi?",
+                self._address,
+            )
+            _LOGGER.warning(
+                "(If this error persists, please set a static IP address: "
+                "https://esphome.io/components/wifi.html#manual-ips)"
+            )
+            raise APIConnectionError(err) from err
 
         _LOGGER.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
         self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -198,14 +203,19 @@ class APIClient(threading.Thread):
         self._socket_open_event.set()
 
         hello = pb.HelloRequest()
-        hello.client_info = f'ESPHome v{const.__version__}'
+        hello.client_info = f"ESPHome v{const.__version__}"
         try:
             resp = self._send_message_await_response(hello, pb.HelloResponse)
         except APIConnectionError as err:
             self._fatal_error(err)
             raise err
-        _LOGGER.debug("Successfully connected to %s ('%s' API=%s.%s)", self._address,
-                      resp.server_info, resp.api_version_major, resp.api_version_minor)
+        _LOGGER.debug(
+            "Successfully connected to %s ('%s' API=%s.%s)",
+            self._address,
+            resp.server_info,
+            resp.api_version_major,
+            resp.api_version_minor,
+        )
         self._connected = True
         self._refresh_ping()
         if self.on_connect is not None:
@@ -270,7 +280,9 @@ class APIClient(threading.Thread):
         req += encoded
         self._write(req)
 
-    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=5):
+    def _send_message_await_response_complex(
+        self, send_msg, do_append, do_stop, timeout=5
+    ):
         event = threading.Event()
         responses = []
 
@@ -295,12 +307,15 @@ class APIClient(threading.Thread):
         def is_response(msg):
             return isinstance(msg, response_type)
 
-        return self._send_message_await_response_complex(send_msg, is_response, is_response,
-                                                         timeout)[0]
+        return self._send_message_await_response_complex(
+            send_msg, is_response, is_response, timeout
+        )[0]
 
     def device_info(self):
         self._check_connected()
-        return self._send_message_await_response(pb.DeviceInfoRequest(), pb.DeviceInfoResponse)
+        return self._send_message_await_response(
+            pb.DeviceInfoRequest(), pb.DeviceInfoResponse
+        )
 
     def ping(self):
         self._check_connected()
@@ -310,7 +325,9 @@ class APIClient(threading.Thread):
         self._check_connected()
 
         try:
-            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
+            self._send_message_await_response(
+                pb.DisconnectRequest(), pb.DisconnectResponse
+            )
         except APIConnectionError:
             pass
         self._close_socket()
@@ -346,12 +363,12 @@ class APIClient(threading.Thread):
                 raise APIConnectionError("No socket!")
             try:
                 val = self._socket.recv(amount - len(ret))
-            except AttributeError:
-                raise APIConnectionError("Socket was closed")
+            except AttributeError as err:
+                raise APIConnectionError("Socket was closed") from err
             except socket.timeout:
                 continue
             except OSError as err:
-                raise APIConnectionError(f"Error while receiving data: {err}")
+                raise APIConnectionError(f"Error while receiving data: {err}") from err
             ret += val
         return ret
 
@@ -415,7 +432,7 @@ class APIClient(threading.Thread):
 
 
 def run_logs(config, address):
-    conf = config['api']
+    conf = config["api"]
     port = conf[CONF_PORT]
     password = conf[CONF_PASSWORD]
     _LOGGER.info("Starting log output from %s using esphome API", address)
@@ -447,24 +464,35 @@ def run_logs(config, address):
             _LOGGER.info("Successfully connected to %s", address)
             return
 
-        wait_time = int(min(1.5**min(tries, 100), 30))
+        wait_time = int(min(1.5 ** min(tries, 100), 30))
         if not has_connects:
-            _LOGGER.warning("Initial connection failed. The ESP might not be connected "
-                            "to WiFi yet (%s). Re-Trying in %s seconds",
-                            error, wait_time)
+            _LOGGER.warning(
+                "Initial connection failed. The ESP might not be connected "
+                "to WiFi yet (%s). Re-Trying in %s seconds",
+                error,
+                wait_time,
+            )
         else:
-            _LOGGER.warning("Couldn't connect to API (%s). Trying to reconnect in %s seconds",
-                            error, wait_time)
-        timer = threading.Timer(wait_time, functools.partial(try_connect, None, tries + 1))
+            _LOGGER.warning(
+                "Couldn't connect to API (%s). Trying to reconnect in %s seconds",
+                error,
+                wait_time,
+            )
+        timer = threading.Timer(
+            wait_time, functools.partial(try_connect, None, tries + 1)
+        )
         timer.start()
         retry_timer.append(timer)
 
     def on_log(msg):
-        time_ = datetime.now().time().strftime('[%H:%M:%S]')
+        time_ = datetime.now().time().strftime("[%H:%M:%S]")
         text = msg.message
         if msg.send_failed:
-            text = color('white', '(Message skipped because it was too big to fit in '
-                                  'TCP buffer - This is only cosmetic)')
+            text = color(
+                Fore.WHITE,
+                "(Message skipped because it was too big to fit in "
+                "TCP buffer - This is only cosmetic)",
+            )
         safe_print(time_ + text)
 
     def on_login():

esphome/automation.py

@@ -1,8 +1,16 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_AUTOMATION_ID, CONF_CONDITION, CONF_ELSE, CONF_ID, CONF_THEN, \
-    CONF_TRIGGER_ID, CONF_TYPE_ID, CONF_TIME
-from esphome.core import coroutine
+from esphome.const import (
+    CONF_AUTOMATION_ID,
+    CONF_CONDITION,
+    CONF_ELSE,
+    CONF_ID,
+    CONF_THEN,
+    CONF_TRIGGER_ID,
+    CONF_TYPE_ID,
+    CONF_TIME,
+)
+from esphome.jsonschema import jschema_extractor
 from esphome.util import Registry
 
 
@@ -13,7 +21,12 @@ def maybe_simple_id(*validators):
 def maybe_conf(conf, *validators):
     validator = cv.All(*validators)
 
+    @jschema_extractor("maybe")
     def validate(value):
+        # pylint: disable=comparison-with-callable
+        if value == jschema_extractor:
+            return validator
+
         if isinstance(value, dict):
             return validator(value)
         with cv.remove_prepend_path([conf]):
@@ -30,36 +43,34 @@ def register_condition(name, condition_type, schema):
     return CONDITION_REGISTRY.register(name, condition_type, schema)
 
 
-Action = cg.esphome_ns.class_('Action')
-Trigger = cg.esphome_ns.class_('Trigger')
+Action = cg.esphome_ns.class_("Action")
+Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
-Condition = cg.esphome_ns.class_('Condition')
+Condition = cg.esphome_ns.class_("Condition")
 CONDITION_REGISTRY = Registry()
-validate_action = cv.validate_registry_entry('action', ACTION_REGISTRY)
-validate_action_list = cv.validate_registry('action', ACTION_REGISTRY)
-validate_condition = cv.validate_registry_entry('condition', CONDITION_REGISTRY)
-validate_condition_list = cv.validate_registry('condition', CONDITION_REGISTRY)
+validate_action = cv.validate_registry_entry("action", ACTION_REGISTRY)
+validate_action_list = cv.validate_registry("action", ACTION_REGISTRY)
+validate_condition = cv.validate_registry_entry("condition", CONDITION_REGISTRY)
+validate_condition_list = cv.validate_registry("condition", CONDITION_REGISTRY)
 
 
 def validate_potentially_and_condition(value):
     if isinstance(value, list):
-        with cv.remove_prepend_path(['and']):
-            return validate_condition({
-                'and': value
-            })
+        with cv.remove_prepend_path(["and"]):
+            return validate_condition({"and": value})
     return validate_condition(value)
 
 
-DelayAction = cg.esphome_ns.class_('DelayAction', Action, cg.Component)
-LambdaAction = cg.esphome_ns.class_('LambdaAction', Action)
-IfAction = cg.esphome_ns.class_('IfAction', Action)
-WhileAction = cg.esphome_ns.class_('WhileAction', Action)
-WaitUntilAction = cg.esphome_ns.class_('WaitUntilAction', Action, cg.Component)
-UpdateComponentAction = cg.esphome_ns.class_('UpdateComponentAction', Action)
-Automation = cg.esphome_ns.class_('Automation')
+DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
+LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
+IfAction = cg.esphome_ns.class_("IfAction", Action)
+WhileAction = cg.esphome_ns.class_("WhileAction", Action)
+WaitUntilAction = cg.esphome_ns.class_("WaitUntilAction", Action, cg.Component)
+UpdateComponentAction = cg.esphome_ns.class_("UpdateComponentAction", Action)
+Automation = cg.esphome_ns.class_("Automation")
 
-LambdaCondition = cg.esphome_ns.class_('LambdaCondition', Condition)
-ForCondition = cg.esphome_ns.class_('ForCondition', Condition, cg.Component)
+LambdaCondition = cg.esphome_ns.class_("LambdaCondition", Condition)
+ForCondition = cg.esphome_ns.class_("ForCondition", Condition, cg.Component)
 
 
 def validate_automation(extra_schema=None, extra_validators=None, single=False):
@@ -83,9 +94,10 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
                 try:
                     return cv.Schema([schema])(value)
                 except cv.Invalid as err2:
-                    if 'extra keys not allowed' in str(err2) and len(err2.path) == 2:
+                    if "extra keys not allowed" in str(err2) and len(err2.path) == 2:
+                        # pylint: disable=raise-missing-from
                         raise err
-                    if 'Unable to find action' in str(err):
+                    if "Unable to find action" in str(err):
                         raise err2
                     raise cv.MultipleInvalid([err, err2])
         elif isinstance(value, dict):
@@ -96,7 +108,13 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
         # This should only happen with invalid configs, but let's have a nice error message.
         return [schema(value)]
 
+    @jschema_extractor("automation")
     def validator(value):
+        # hack to get the schema
+        # pylint: disable=comparison-with-callable
+        if value == jschema_extractor:
+            return schema
+
         value = validator_(value)
         if extra_validators is not None:
             value = cv.Schema([extra_validators])(value)
@@ -109,162 +127,198 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
     return validator
 
 
-AUTOMATION_SCHEMA = cv.Schema({
-    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(Trigger),
-    cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_id(Automation),
-    cv.Required(CONF_THEN): validate_action_list,
-})
+AUTOMATION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(Trigger),
+        cv.GenerateID(CONF_AUTOMATION_ID): cv.declare_id(Automation),
+        cv.Required(CONF_THEN): validate_action_list,
+    }
+)
 
-AndCondition = cg.esphome_ns.class_('AndCondition', Condition)
-OrCondition = cg.esphome_ns.class_('OrCondition', Condition)
-NotCondition = cg.esphome_ns.class_('NotCondition', Condition)
+AndCondition = cg.esphome_ns.class_("AndCondition", Condition)
+OrCondition = cg.esphome_ns.class_("OrCondition", Condition)
+NotCondition = cg.esphome_ns.class_("NotCondition", Condition)
 
 
-@register_condition('and', AndCondition, validate_condition_list)
-def and_condition_to_code(config, condition_id, template_arg, args):
-    conditions = yield build_condition_list(config, template_arg, args)
-    yield cg.new_Pvariable(condition_id, template_arg, conditions)
+@register_condition("and", AndCondition, validate_condition_list)
+async def and_condition_to_code(config, condition_id, template_arg, args):
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(condition_id, template_arg, conditions)
 
 
-@register_condition('or', OrCondition, validate_condition_list)
-def or_condition_to_code(config, condition_id, template_arg, args):
-    conditions = yield build_condition_list(config, template_arg, args)
-    yield cg.new_Pvariable(condition_id, template_arg, conditions)
+@register_condition("or", OrCondition, validate_condition_list)
+async def or_condition_to_code(config, condition_id, template_arg, args):
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(condition_id, template_arg, conditions)
 
 
-@register_condition('not', NotCondition, validate_potentially_and_condition)
-def not_condition_to_code(config, condition_id, template_arg, args):
-    condition = yield build_condition(config, template_arg, args)
-    yield cg.new_Pvariable(condition_id, template_arg, condition)
+@register_condition("not", NotCondition, validate_potentially_and_condition)
+async def not_condition_to_code(config, condition_id, template_arg, args):
+    condition = await build_condition(config, template_arg, args)
+    return cg.new_Pvariable(condition_id, template_arg, condition)
 
 
-@register_condition('lambda', LambdaCondition, cv.lambda_)
-def lambda_condition_to_code(config, condition_id, template_arg, args):
-    lambda_ = yield cg.process_lambda(config, args, return_type=bool)
-    yield cg.new_Pvariable(condition_id, template_arg, lambda_)
+@register_condition("lambda", LambdaCondition, cv.returning_lambda)
+async def lambda_condition_to_code(config, condition_id, template_arg, args):
+    lambda_ = await cg.process_lambda(config, args, return_type=bool)
+    return cg.new_Pvariable(condition_id, template_arg, lambda_)
 
 
-@register_condition('for', ForCondition, cv.Schema({
-    cv.Required(CONF_TIME): cv.templatable(cv.positive_time_period_milliseconds),
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-}).extend(cv.COMPONENT_SCHEMA))
-def for_condition_to_code(config, condition_id, template_arg, args):
-    condition = yield build_condition(config[CONF_CONDITION], cg.TemplateArguments(), [])
+@register_condition(
+    "for",
+    ForCondition,
+    cv.Schema(
+        {
+            cv.Required(CONF_TIME): cv.templatable(
+                cv.positive_time_period_milliseconds
+            ),
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+)
+async def for_condition_to_code(config, condition_id, template_arg, args):
+    condition = await build_condition(
+        config[CONF_CONDITION], cg.TemplateArguments(), []
+    )
     var = cg.new_Pvariable(condition_id, template_arg, condition)
-    yield cg.register_component(var, config)
-    templ = yield cg.templatable(config[CONF_TIME], args, cg.uint32)
+    await cg.register_component(var, config)
+    templ = await cg.templatable(config[CONF_TIME], args, cg.uint32)
     cg.add(var.set_time(templ))
-    yield var
+    return var
 
 
-@register_action('delay', DelayAction, cv.templatable(cv.positive_time_period_milliseconds))
-def delay_action_to_code(config, action_id, template_arg, args):
+@register_action(
+    "delay", DelayAction, cv.templatable(cv.positive_time_period_milliseconds)
+)
+async def delay_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
-    yield cg.register_component(var, {})
-    template_ = yield cg.templatable(config, args, cg.uint32)
+    await cg.register_component(var, {})
+    template_ = await cg.templatable(config, args, cg.uint32)
     cg.add(var.set_delay(template_))
-    yield var
+    return var
 
 
-@register_action('if', IfAction, cv.All({
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    cv.Optional(CONF_THEN): validate_action_list,
-    cv.Optional(CONF_ELSE): validate_action_list,
-}, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE)))
-def if_action_to_code(config, action_id, template_arg, args):
-    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
+@register_action(
+    "if",
+    IfAction,
+    cv.All(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+            cv.Optional(CONF_THEN): validate_action_list,
+            cv.Optional(CONF_ELSE): validate_action_list,
+        },
+        cv.has_at_least_one_key(CONF_THEN, CONF_ELSE),
+    ),
+)
+async def if_action_to_code(config, action_id, template_arg, args):
+    conditions = await build_condition(config[CONF_CONDITION], template_arg, args)
     var = cg.new_Pvariable(action_id, template_arg, conditions)
     if CONF_THEN in config:
-        actions = yield build_action_list(config[CONF_THEN], template_arg, args)
+        actions = await build_action_list(config[CONF_THEN], template_arg, args)
         cg.add(var.add_then(actions))
     if CONF_ELSE in config:
-        actions = yield build_action_list(config[CONF_ELSE], template_arg, args)
+        actions = await build_action_list(config[CONF_ELSE], template_arg, args)
         cg.add(var.add_else(actions))
-    yield var
+    return var
 
 
-@register_action('while', WhileAction, cv.Schema({
-    cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    cv.Required(CONF_THEN): validate_action_list,
-}))
-def while_action_to_code(config, action_id, template_arg, args):
-    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
+@register_action(
+    "while",
+    WhileAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+            cv.Required(CONF_THEN): validate_action_list,
+        }
+    ),
+)
+async def while_action_to_code(config, action_id, template_arg, args):
+    conditions = await build_condition(config[CONF_CONDITION], template_arg, args)
     var = cg.new_Pvariable(action_id, template_arg, conditions)
-    actions = yield build_action_list(config[CONF_THEN], template_arg, args)
+    actions = await build_action_list(config[CONF_THEN], template_arg, args)
     cg.add(var.add_then(actions))
-    yield var
+    return var
 
 
 def validate_wait_until(value):
-    schema = cv.Schema({
-        cv.Required(CONF_CONDITION): validate_potentially_and_condition,
-    })
+    schema = cv.Schema(
+        {
+            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+        }
+    )
     if isinstance(value, dict) and CONF_CONDITION in value:
         return schema(value)
     return validate_wait_until({CONF_CONDITION: value})
 
 
-@register_action('wait_until', WaitUntilAction, validate_wait_until)
-def wait_until_action_to_code(config, action_id, template_arg, args):
-    conditions = yield build_condition(config[CONF_CONDITION], template_arg, args)
+@register_action("wait_until", WaitUntilAction, validate_wait_until)
+async def wait_until_action_to_code(config, action_id, template_arg, args):
+    conditions = await build_condition(config[CONF_CONDITION], template_arg, args)
     var = cg.new_Pvariable(action_id, template_arg, conditions)
-    yield cg.register_component(var, {})
-    yield var
+    await cg.register_component(var, {})
+    return var
 
 
-@register_action('lambda', LambdaAction, cv.lambda_)
-def lambda_action_to_code(config, action_id, template_arg, args):
-    lambda_ = yield cg.process_lambda(config, args, return_type=cg.void)
-    yield cg.new_Pvariable(action_id, template_arg, lambda_)
+@register_action("lambda", LambdaAction, cv.lambda_)
+async def lambda_action_to_code(config, action_id, template_arg, args):
+    lambda_ = await cg.process_lambda(config, args, return_type=cg.void)
+    return cg.new_Pvariable(action_id, template_arg, lambda_)
 
 
-@register_action('component.update', UpdateComponentAction, maybe_simple_id({
-    cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
-}))
-def component_update_action_to_code(config, action_id, template_arg, args):
-    comp = yield cg.get_variable(config[CONF_ID])
-    yield cg.new_Pvariable(action_id, template_arg, comp)
+@register_action(
+    "component.update",
+    UpdateComponentAction,
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
+)
+async def component_update_action_to_code(config, action_id, template_arg, args):
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)
 
 
-@coroutine
-def build_action(full_config, template_arg, args):
-    registry_entry, config = cg.extract_registry_entry_config(ACTION_REGISTRY, full_config)
+async def build_action(full_config, template_arg, args):
+    registry_entry, config = cg.extract_registry_entry_config(
+        ACTION_REGISTRY, full_config
+    )
     action_id = full_config[CONF_TYPE_ID]
     builder = registry_entry.coroutine_fun
-    yield builder(config, action_id, template_arg, args)
+    ret = await builder(config, action_id, template_arg, args)
+    return ret
 
 
-@coroutine
-def build_action_list(config, templ, arg_type):
+async def build_action_list(config, templ, arg_type):
     actions = []
     for conf in config:
-        action = yield build_action(conf, templ, arg_type)
+        action = await build_action(conf, templ, arg_type)
         actions.append(action)
-    yield actions
+    return actions
 
 
-@coroutine
-def build_condition(full_config, template_arg, args):
-    registry_entry, config = cg.extract_registry_entry_config(CONDITION_REGISTRY, full_config)
+async def build_condition(full_config, template_arg, args):
+    registry_entry, config = cg.extract_registry_entry_config(
+        CONDITION_REGISTRY, full_config
+    )
     action_id = full_config[CONF_TYPE_ID]
     builder = registry_entry.coroutine_fun
-    yield builder(config, action_id, template_arg, args)
+    ret = await builder(config, action_id, template_arg, args)
+    return ret
 
 
-@coroutine
-def build_condition_list(config, templ, args):
+async def build_condition_list(config, templ, args):
     conditions = []
     for conf in config:
-        condition = yield build_condition(conf, templ, args)
+        condition = await build_condition(conf, templ, args)
         conditions.append(condition)
-    yield conditions
+    return conditions
 
 
-@coroutine
-def build_automation(trigger, args, config):
+async def build_automation(trigger, args, config):
     arg_types = [arg[0] for arg in args]
     templ = cg.TemplateArguments(*arg_types)
     obj = cg.new_Pvariable(config[CONF_AUTOMATION_ID], templ, trigger)
-    actions = yield build_action_list(config[CONF_THEN], templ, args)
+    actions = await build_action_list(config[CONF_THEN], templ, args)
     cg.add(obj.add_actions(actions))
-    yield obj
+    return obj

esphome/boards.py

@@ -0,0 +1,875 @@
+ESP8266_BASE_PINS = {
+    "A0": 17,
+    "SS": 15,
+    "MOSI": 13,
+    "MISO": 12,
+    "SCK": 14,
+    "SDA": 4,
+    "SCL": 5,
+    "RX": 3,
+    "TX": 1,
+}
+
+ESP8266_BOARD_PINS = {
+    "d1": {
+        "D0": 3,
+        "D1": 1,
+        "D2": 16,
+        "D3": 5,
+        "D4": 4,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 0,
+        "D9": 2,
+        "D10": 15,
+        "D11": 13,
+        "D12": 14,
+        "D13": 14,
+        "D14": 4,
+        "D15": 5,
+        "LED": 2,
+    },
+    "d1_mini": {
+        "D0": 16,
+        "D1": 5,
+        "D2": 4,
+        "D3": 0,
+        "D4": 2,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 15,
+        "LED": 2,
+    },
+    "d1_mini_lite": "d1_mini",
+    "d1_mini_pro": "d1_mini",
+    "esp01": {},
+    "esp01_1m": {},
+    "esp07": {},
+    "esp12e": {},
+    "esp210": {},
+    "esp8285": {},
+    "esp_wroom_02": {},
+    "espduino": {"LED": 16},
+    "espectro": {"LED": 15, "BUTTON": 2},
+    "espino": {"LED": 2, "LED_RED": 2, "LED_GREEN": 4, "LED_BLUE": 5, "BUTTON": 0},
+    "espinotee": {"LED": 16},
+    "espresso_lite_v1": {"LED": 16},
+    "espresso_lite_v2": {"LED": 2},
+    "gen4iod": {},
+    "heltec_wifi_kit_8": "d1_mini",
+    "huzzah": {
+        "LED": 0,
+        "LED_RED": 0,
+        "LED_BLUE": 2,
+        "D4": 4,
+        "D5": 5,
+        "D12": 12,
+        "D13": 13,
+        "D14": 14,
+        "D15": 15,
+        "D16": 16,
+    },
+    "inventone": {},
+    "modwifi": {},
+    "nodemcu": {
+        "D0": 16,
+        "D1": 5,
+        "D2": 4,
+        "D3": 0,
+        "D4": 2,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 15,
+        "D9": 3,
+        "D10": 1,
+        "LED": 16,
+    },
+    "nodemcuv2": "nodemcu",
+    "oak": {
+        "P0": 2,
+        "P1": 5,
+        "P2": 0,
+        "P3": 3,
+        "P4": 1,
+        "P5": 4,
+        "P6": 15,
+        "P7": 13,
+        "P8": 12,
+        "P9": 14,
+        "P10": 16,
+        "P11": 17,
+        "LED": 5,
+    },
+    "phoenix_v1": {"LED": 16},
+    "phoenix_v2": {"LED": 2},
+    "sparkfunBlynk": "thing",
+    "thing": {"LED": 5, "SDA": 2, "SCL": 14},
+    "thingdev": "thing",
+    "wifi_slot": {"LED": 2},
+    "wifiduino": {
+        "D0": 3,
+        "D1": 1,
+        "D2": 2,
+        "D3": 0,
+        "D4": 4,
+        "D5": 5,
+        "D6": 16,
+        "D7": 14,
+        "D8": 12,
+        "D9": 13,
+        "D10": 15,
+        "D11": 13,
+        "D12": 12,
+        "D13": 14,
+    },
+    "wifinfo": {
+        "LED": 12,
+        "D0": 16,
+        "D1": 5,
+        "D2": 4,
+        "D3": 0,
+        "D4": 2,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 15,
+        "D9": 3,
+        "D10": 1,
+    },
+    "wio_link": {"LED": 2, "GROVE": 15, "D0": 14, "D1": 12, "D2": 13, "BUTTON": 0},
+    "wio_node": {"LED": 2, "GROVE": 15, "D0": 3, "D1": 5, "BUTTON": 0},
+    "xinabox_cw01": {"SDA": 2, "SCL": 14, "LED": 5, "LED_RED": 12, "LED_GREEN": 13},
+}
+
+FLASH_SIZE_1_MB = 2 ** 20
+FLASH_SIZE_512_KB = FLASH_SIZE_1_MB // 2
+FLASH_SIZE_2_MB = 2 * FLASH_SIZE_1_MB
+FLASH_SIZE_4_MB = 4 * FLASH_SIZE_1_MB
+FLASH_SIZE_16_MB = 16 * FLASH_SIZE_1_MB
+
+ESP8266_FLASH_SIZES = {
+    "d1": FLASH_SIZE_4_MB,
+    "d1_mini": FLASH_SIZE_4_MB,
+    "d1_mini_lite": FLASH_SIZE_1_MB,
+    "d1_mini_pro": FLASH_SIZE_16_MB,
+    "esp01": FLASH_SIZE_512_KB,
+    "esp01_1m": FLASH_SIZE_1_MB,
+    "esp07": FLASH_SIZE_4_MB,
+    "esp12e": FLASH_SIZE_4_MB,
+    "esp210": FLASH_SIZE_4_MB,
+    "esp8285": FLASH_SIZE_1_MB,
+    "esp_wroom_02": FLASH_SIZE_2_MB,
+    "espduino": FLASH_SIZE_4_MB,
+    "espectro": FLASH_SIZE_4_MB,
+    "espino": FLASH_SIZE_4_MB,
+    "espinotee": FLASH_SIZE_4_MB,
+    "espresso_lite_v1": FLASH_SIZE_4_MB,
+    "espresso_lite_v2": FLASH_SIZE_4_MB,
+    "gen4iod": FLASH_SIZE_512_KB,
+    "heltec_wifi_kit_8": FLASH_SIZE_4_MB,
+    "huzzah": FLASH_SIZE_4_MB,
+    "inventone": FLASH_SIZE_4_MB,
+    "modwifi": FLASH_SIZE_2_MB,
+    "nodemcu": FLASH_SIZE_4_MB,
+    "nodemcuv2": FLASH_SIZE_4_MB,
+    "oak": FLASH_SIZE_4_MB,
+    "phoenix_v1": FLASH_SIZE_4_MB,
+    "phoenix_v2": FLASH_SIZE_4_MB,
+    "sparkfunBlynk": FLASH_SIZE_4_MB,
+    "thing": FLASH_SIZE_512_KB,
+    "thingdev": FLASH_SIZE_512_KB,
+    "wifi_slot": FLASH_SIZE_1_MB,
+    "wifiduino": FLASH_SIZE_4_MB,
+    "wifinfo": FLASH_SIZE_1_MB,
+    "wio_link": FLASH_SIZE_4_MB,
+    "wio_node": FLASH_SIZE_4_MB,
+    "xinabox_cw01": FLASH_SIZE_4_MB,
+}
+
+ESP8266_LD_SCRIPTS = {
+    FLASH_SIZE_512_KB: ("eagle.flash.512k0.ld", "eagle.flash.512k.ld"),
+    FLASH_SIZE_1_MB: ("eagle.flash.1m0.ld", "eagle.flash.1m.ld"),
+    FLASH_SIZE_2_MB: ("eagle.flash.2m.ld", "eagle.flash.2m.ld"),
+    FLASH_SIZE_4_MB: ("eagle.flash.4m.ld", "eagle.flash.4m.ld"),
+    FLASH_SIZE_16_MB: ("eagle.flash.16m.ld", "eagle.flash.16m14m.ld"),
+}
+
+ESP32_BASE_PINS = {
+    "TX": 1,
+    "RX": 3,
+    "SDA": 21,
+    "SCL": 22,
+    "SS": 5,
+    "MOSI": 23,
+    "MISO": 19,
+    "SCK": 18,
+    "A0": 36,
+    "A3": 39,
+    "A4": 32,
+    "A5": 33,
+    "A6": 34,
+    "A7": 35,
+    "A10": 4,
+    "A11": 0,
+    "A12": 2,
+    "A13": 15,
+    "A14": 13,
+    "A15": 12,
+    "A16": 14,
+    "A17": 27,
+    "A18": 25,
+    "A19": 26,
+    "T0": 4,
+    "T1": 0,
+    "T2": 2,
+    "T3": 15,
+    "T4": 13,
+    "T5": 12,
+    "T6": 14,
+    "T7": 27,
+    "T8": 33,
+    "T9": 32,
+    "DAC1": 25,
+    "DAC2": 26,
+    "SVP": 36,
+    "SVN": 39,
+}
+
+ESP32_BOARD_PINS = {
+    "alksesp32": {
+        "A0": 32,
+        "A1": 33,
+        "A2": 25,
+        "A3": 26,
+        "A4": 27,
+        "A5": 14,
+        "A6": 12,
+        "A7": 15,
+        "D0": 40,
+        "D1": 41,
+        "D10": 19,
+        "D11": 21,
+        "D12": 22,
+        "D13": 23,
+        "D2": 15,
+        "D3": 2,
+        "D4": 0,
+        "D5": 4,
+        "D6": 16,
+        "D7": 17,
+        "D8": 5,
+        "D9": 18,
+        "DHT_PIN": 26,
+        "LED": 23,
+        "L_B": 5,
+        "L_G": 17,
+        "L_R": 22,
+        "L_RGB_B": 16,
+        "L_RGB_G": 21,
+        "L_RGB_R": 4,
+        "L_Y": 23,
+        "MISO": 22,
+        "MOSI": 21,
+        "PHOTO": 25,
+        "PIEZO1": 19,
+        "PIEZO2": 18,
+        "POT1": 32,
+        "POT2": 33,
+        "S1": 4,
+        "S2": 16,
+        "S3": 18,
+        "S4": 19,
+        "S5": 21,
+        "SCK": 23,
+        "SCL": 14,
+        "SDA": 27,
+        "SS": 19,
+        "SW1": 15,
+        "SW2": 2,
+        "SW3": 0,
+    },
+    "bpi-bit": {
+        "BUTTON_A": 35,
+        "BUTTON_B": 27,
+        "BUZZER": 25,
+        "LIGHT_SENSOR1": 36,
+        "LIGHT_SENSOR2": 39,
+        "MPU9250_INT": 0,
+        "P0": 25,
+        "P1": 32,
+        "P10": 26,
+        "P11": 27,
+        "P12": 2,
+        "P13": 18,
+        "P14": 19,
+        "P15": 23,
+        "P16": 5,
+        "P19": 22,
+        "P2": 33,
+        "P20": 21,
+        "P3": 13,
+        "P4": 15,
+        "P5": 35,
+        "P6": 12,
+        "P7": 14,
+        "P8": 16,
+        "P9": 17,
+        "RGB_LED": 4,
+        "TEMPERATURE_SENSOR": 34,
+    },
+    "d-duino-32": {
+        "D1": 5,
+        "D10": 1,
+        "D2": 4,
+        "D3": 0,
+        "D4": 2,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 15,
+        "D9": 3,
+        "MISO": 12,
+        "MOSI": 13,
+        "SCK": 14,
+        "SCL": 4,
+        "SDA": 5,
+        "SS": 15,
+    },
+    "esp-wrover-kit": {},
+    "esp32-devkitlipo": {},
+    "esp32-evb": {
+        "BUTTON": 34,
+        "MISO": 15,
+        "MOSI": 2,
+        "SCK": 14,
+        "SCL": 16,
+        "SDA": 13,
+        "SS": 17,
+    },
+    "esp32-gateway": {"BUTTON": 34, "LED": 33, "SCL": 16, "SDA": 32},
+    "esp32-poe-iso": {
+        "BUTTON": 34,
+        "MISO": 15,
+        "MOSI": 2,
+        "SCK": 14,
+        "SCL": 16,
+        "SDA": 13,
+    },
+    "esp32-poe": {"BUTTON": 34, "MISO": 15, "MOSI": 2, "SCK": 14, "SCL": 16, "SDA": 13},
+    "esp32-pro": {
+        "BUTTON": 34,
+        "MISO": 15,
+        "MOSI": 2,
+        "SCK": 14,
+        "SCL": 16,
+        "SDA": 13,
+        "SS": 17,
+    },
+    "esp320": {
+        "LED": 5,
+        "MISO": 12,
+        "MOSI": 13,
+        "SCK": 14,
+        "SCL": 14,
+        "SDA": 2,
+        "SS": 15,
+    },
+    "esp32cam": {},
+    "esp32dev": {},
+    "esp32doit-devkit-v1": {"LED": 2},
+    "esp32thing": {"BUTTON": 0, "LED": 5, "SS": 2},
+    "esp32vn-iot-uno": {},
+    "espea32": {"BUTTON": 0, "LED": 5},
+    "espectro32": {"LED": 15, "SD_SS": 33},
+    "espino32": {"BUTTON": 0, "LED": 16},
+    "featheresp32": {
+        "A0": 26,
+        "A1": 25,
+        "A10": 27,
+        "A11": 12,
+        "A12": 13,
+        "A13": 35,
+        "A2": 34,
+        "A4": 36,
+        "A5": 4,
+        "A6": 14,
+        "A7": 32,
+        "A8": 15,
+        "A9": 33,
+        "Ax": 2,
+        "LED": 13,
+        "MOSI": 18,
+        "RX": 16,
+        "SCK": 5,
+        "SDA": 23,
+        "SS": 33,
+        "TX": 17,
+    },
+    "firebeetle32": {"LED": 2},
+    "fm-devkit": {
+        "D0": 34,
+        "D1": 35,
+        "D10": 0,
+        "D2": 32,
+        "D3": 33,
+        "D4": 27,
+        "D5": 14,
+        "D6": 12,
+        "D7": 13,
+        "D8": 15,
+        "D9": 23,
+        "I2S_DOUT": 22,
+        "I2S_LRCLK": 25,
+        "I2S_MCLK": 2,
+        "I2S_SCLK": 26,
+        "LED": 5,
+        "SCL": 17,
+        "SDA": 16,
+        "SW1": 4,
+        "SW2": 18,
+        "SW3": 19,
+        "SW4": 21,
+    },
+    "frogboard": {},
+    "heltec_wifi_kit_32": {
+        "A1": 37,
+        "A2": 38,
+        "BUTTON": 0,
+        "LED": 25,
+        "RST_OLED": 16,
+        "SCL_OLED": 15,
+        "SDA_OLED": 4,
+        "Vext": 21,
+    },
+    "heltec_wifi_lora_32": {
+        "BUTTON": 0,
+        "DIO0": 26,
+        "DIO1": 33,
+        "DIO2": 32,
+        "LED": 25,
+        "MOSI": 27,
+        "RST_LoRa": 14,
+        "RST_OLED": 16,
+        "SCK": 5,
+        "SCL_OLED": 15,
+        "SDA_OLED": 4,
+        "SS": 18,
+        "Vext": 21,
+    },
+    "heltec_wifi_lora_32_V2": {
+        "BUTTON": 0,
+        "DIO0": 26,
+        "DIO1": 35,
+        "DIO2": 34,
+        "LED": 25,
+        "MOSI": 27,
+        "RST_LoRa": 14,
+        "RST_OLED": 16,
+        "SCK": 5,
+        "SCL_OLED": 15,
+        "SDA_OLED": 4,
+        "SS": 18,
+        "Vext": 21,
+    },
+    "heltec_wireless_stick": {
+        "BUTTON": 0,
+        "DIO0": 26,
+        "DIO1": 35,
+        "DIO2": 34,
+        "LED": 25,
+        "MOSI": 27,
+        "RST_LoRa": 14,
+        "RST_OLED": 16,
+        "SCK": 5,
+        "SCL_OLED": 15,
+        "SDA_OLED": 4,
+        "SS": 18,
+        "Vext": 21,
+    },
+    "hornbill32dev": {"BUTTON": 0, "LED": 13},
+    "hornbill32minima": {"SS": 2},
+    "intorobot": {
+        "A1": 39,
+        "A2": 35,
+        "A3": 25,
+        "A4": 26,
+        "A5": 14,
+        "A6": 12,
+        "A7": 15,
+        "A8": 13,
+        "A9": 2,
+        "BUTTON": 0,
+        "D0": 19,
+        "D1": 23,
+        "D2": 18,
+        "D3": 17,
+        "D4": 16,
+        "D5": 5,
+        "D6": 4,
+        "LED": 4,
+        "MISO": 17,
+        "MOSI": 16,
+        "RGB_B_BUILTIN": 22,
+        "RGB_G_BUILTIN": 21,
+        "RGB_R_BUILTIN": 27,
+        "SCL": 19,
+        "SDA": 23,
+        "T0": 19,
+        "T1": 23,
+        "T2": 18,
+        "T3": 17,
+        "T4": 16,
+        "T5": 5,
+        "T6": 4,
+    },
+    "iotaap_magnolia": {},
+    "iotbusio": {},
+    "iotbusproteus": {},
+    "lolin32": {"LED": 5},
+    "lolin32_lite": {"LED": 22},
+    "lolin_d32": {"LED": 5, "_VBAT": 35},
+    "lolin_d32_pro": {"LED": 5, "_VBAT": 35},
+    "lopy": {
+        "A1": 37,
+        "A2": 38,
+        "LED": 0,
+        "MISO": 37,
+        "MOSI": 22,
+        "SCK": 13,
+        "SCL": 13,
+        "SDA": 12,
+        "SS": 17,
+    },
+    "lopy4": {
+        "A1": 37,
+        "A2": 38,
+        "LED": 0,
+        "MISO": 37,
+        "MOSI": 22,
+        "SCK": 13,
+        "SCL": 13,
+        "SDA": 12,
+        "SS": 18,
+    },
+    "m5stack-core-esp32": {
+        "ADC1": 35,
+        "ADC2": 36,
+        "G0": 0,
+        "G1": 1,
+        "G12": 12,
+        "G13": 13,
+        "G15": 15,
+        "G16": 16,
+        "G17": 17,
+        "G18": 18,
+        "G19": 19,
+        "G2": 2,
+        "G21": 21,
+        "G22": 22,
+        "G23": 23,
+        "G25": 25,
+        "G26": 26,
+        "G3": 3,
+        "G34": 34,
+        "G35": 35,
+        "G36": 36,
+        "G5": 5,
+        "RXD2": 16,
+        "TXD2": 17,
+    },
+    "m5stack-fire": {
+        "ADC1": 35,
+        "ADC2": 36,
+        "G0": 0,
+        "G1": 1,
+        "G12": 12,
+        "G13": 13,
+        "G15": 15,
+        "G16": 16,
+        "G17": 17,
+        "G18": 18,
+        "G19": 19,
+        "G2": 2,
+        "G21": 21,
+        "G22": 22,
+        "G23": 23,
+        "G25": 25,
+        "G26": 26,
+        "G3": 3,
+        "G34": 34,
+        "G35": 35,
+        "G36": 36,
+        "G5": 5,
+    },
+    "m5stack-grey": {
+        "ADC1": 35,
+        "ADC2": 36,
+        "G0": 0,
+        "G1": 1,
+        "G12": 12,
+        "G13": 13,
+        "G15": 15,
+        "G16": 16,
+        "G17": 17,
+        "G18": 18,
+        "G19": 19,
+        "G2": 2,
+        "G21": 21,
+        "G22": 22,
+        "G23": 23,
+        "G25": 25,
+        "G26": 26,
+        "G3": 3,
+        "G34": 34,
+        "G35": 35,
+        "G36": 36,
+        "G5": 5,
+        "RXD2": 16,
+        "TXD2": 17,
+    },
+    "m5stick-c": {
+        "ADC1": 35,
+        "ADC2": 36,
+        "G0": 0,
+        "G10": 10,
+        "G26": 26,
+        "G32": 32,
+        "G33": 33,
+        "G36": 36,
+        "G37": 37,
+        "G39": 39,
+        "G9": 9,
+        "MISO": 36,
+        "MOSI": 15,
+        "SCK": 13,
+        "SCL": 33,
+        "SDA": 32,
+    },
+    "magicbit": {
+        "BLUE_LED": 17,
+        "BUZZER": 25,
+        "GREEN_LED": 16,
+        "LDR": 36,
+        "LED": 16,
+        "LEFT_BUTTON": 35,
+        "MOTOR1A": 27,
+        "MOTOR1B": 18,
+        "MOTOR2A": 16,
+        "MOTOR2B": 17,
+        "POT": 39,
+        "RED_LED": 27,
+        "RIGHT_PUTTON": 34,
+        "YELLOW_LED": 18,
+    },
+    "mhetesp32devkit": {"LED": 2},
+    "mhetesp32minikit": {"LED": 2},
+    "microduino-core-esp32": {
+        "A0": 12,
+        "A1": 13,
+        "A10": 25,
+        "A11": 26,
+        "A12": 27,
+        "A13": 14,
+        "A2": 15,
+        "A3": 4,
+        "A6": 38,
+        "A7": 37,
+        "A8": 32,
+        "A9": 33,
+        "D0": 3,
+        "D1": 1,
+        "D10": 5,
+        "D11": 23,
+        "D12": 19,
+        "D13": 18,
+        "D14": 12,
+        "D15": 13,
+        "D16": 15,
+        "D17": 4,
+        "D18": 22,
+        "D19": 21,
+        "D2": 16,
+        "D20": 38,
+        "D21": 37,
+        "D3": 17,
+        "D4": 32,
+        "D5": 33,
+        "D6": 25,
+        "D7": 26,
+        "D8": 27,
+        "D9": 14,
+        "SCL": 21,
+        "SCL1": 13,
+        "SDA": 22,
+        "SDA1": 12,
+    },
+    "nano32": {"BUTTON": 0, "LED": 16},
+    "nina_w10": {
+        "D0": 3,
+        "D1": 1,
+        "D10": 5,
+        "D11": 19,
+        "D12": 23,
+        "D13": 18,
+        "D14": 13,
+        "D15": 12,
+        "D16": 32,
+        "D17": 33,
+        "D18": 21,
+        "D19": 34,
+        "D2": 26,
+        "D20": 36,
+        "D21": 39,
+        "D3": 25,
+        "D4": 35,
+        "D5": 27,
+        "D6": 22,
+        "D7": 0,
+        "D8": 15,
+        "D9": 14,
+        "LED_BLUE": 21,
+        "LED_GREEN": 33,
+        "LED_RED": 23,
+        "SCL": 13,
+        "SDA": 12,
+        "SW1": 33,
+        "SW2": 27,
+    },
+    "node32s": {},
+    "nodemcu-32s": {"BUTTON": 0, "LED": 2},
+    "odroid_esp32": {"ADC1": 35, "ADC2": 36, "LED": 2, "SCL": 4, "SDA": 15, "SS": 22},
+    "onehorse32dev": {"A1": 37, "A2": 38, "BUTTON": 0, "LED": 5},
+    "oroca_edubot": {
+        "A0": 34,
+        "A1": 39,
+        "A2": 36,
+        "A3": 33,
+        "D0": 4,
+        "D1": 16,
+        "D2": 17,
+        "D3": 22,
+        "D4": 23,
+        "D5": 5,
+        "D6": 18,
+        "D7": 19,
+        "D8": 33,
+        "LED": 13,
+        "MOSI": 18,
+        "RX": 16,
+        "SCK": 5,
+        "SDA": 23,
+        "SS": 2,
+        "TX": 17,
+        "VBAT": 35,
+    },
+    "pico32": {},
+    "pocket_32": {"LED": 16},
+    "pycom_gpy": {
+        "A1": 37,
+        "A2": 38,
+        "LED": 0,
+        "MISO": 37,
+        "MOSI": 22,
+        "SCK": 13,
+        "SCL": 13,
+        "SDA": 12,
+        "SS": 17,
+    },
+    "quantum": {},
+    "sparkfun_lora_gateway_1-channel": {"MISO": 12, "MOSI": 13, "SCK": 14, "SS": 16},
+    "tinypico": {},
+    "ttgo-lora32-v1": {
+        "A1": 37,
+        "A2": 38,
+        "BUTTON": 0,
+        "LED": 2,
+        "MOSI": 27,
+        "SCK": 5,
+        "SS": 18,
+    },
+    "ttgo-t-beam": {"BUTTON": 39, "LED": 14, "MOSI": 27, "SCK": 5, "SS": 18},
+    "ttgo-t-watch": {"BUTTON": 36, "MISO": 2, "MOSI": 15, "SCK": 14, "SS": 13},
+    "ttgo-t1": {"LED": 22, "MISO": 2, "MOSI": 15, "SCK": 14, "SCL": 23, "SS": 13},
+    "ttgo-t7-v13-mini32": {"LED": 22},
+    "ttgo-t7-v14-mini32": {"LED": 19},
+    "turta_iot_node": {},
+    "vintlabs-devkit-v1": {
+        "LED": 2,
+        "PWM0": 12,
+        "PWM1": 13,
+        "PWM2": 14,
+        "PWM3": 15,
+        "PWM4": 16,
+        "PWM5": 17,
+        "PWM6": 18,
+        "PWM7": 19,
+    },
+    "wemos_d1_mini32": {
+        "D0": 26,
+        "D1": 22,
+        "D2": 21,
+        "D3": 17,
+        "D4": 16,
+        "D5": 18,
+        "D6": 19,
+        "D7": 23,
+        "D8": 5,
+        "LED": 2,
+        "RXD": 3,
+        "TXD": 1,
+        "_VBAT": 35,
+    },
+    "wemosbat": {"LED": 16},
+    "wesp32": {"MISO": 32, "SCL": 4, "SDA": 15},
+    "widora-air": {
+        "A1": 39,
+        "A2": 35,
+        "A3": 25,
+        "A4": 26,
+        "A5": 14,
+        "A6": 12,
+        "A7": 15,
+        "A8": 13,
+        "A9": 2,
+        "BUTTON": 0,
+        "D0": 19,
+        "D1": 23,
+        "D2": 18,
+        "D3": 17,
+        "D4": 16,
+        "D5": 5,
+        "D6": 4,
+        "LED": 25,
+        "MISO": 17,
+        "MOSI": 16,
+        "SCL": 19,
+        "SDA": 23,
+        "T0": 19,
+        "T1": 23,
+        "T2": 18,
+        "T3": 17,
+        "T4": 16,
+        "T5": 5,
+        "T6": 4,
+    },
+    "xinabox_cw02": {"LED": 27},
+}
+
+ESP32_C3_BASE_PINS = {
+    "TX": 21,
+    "RX": 20,
+    "ADC1_0": 0,
+    "ADC1_1": 1,
+    "ADC1_2": 2,
+    "ADC1_3": 3,
+    "ADC1_4": 4,
+    "ADC2_0": 5,
+}
+
+ESP32_C3_BOARD_PINS = {
+    "esp32-c3-devkitm-1": {"LED": 8},
+    "esp32-c3-devkitc-02": "esp32-c3-devkitm-1",
+}

esphome/codegen.py

@@ -9,18 +9,73 @@
 
 # pylint: disable=unused-import
 from esphome.cpp_generator import (  # noqa
-    Expression, RawExpression, RawStatement, TemplateArguments,
-    StructInitializer, ArrayInitializer, safe_exp, Statement, LineComment,
-    progmem_array, statement, variable, Pvariable, new_Pvariable,
-    add, add_global, add_library, add_build_flag, add_define,
-    get_variable, get_variable_with_full_id, process_lambda, is_template, templatable, MockObj,
-    MockObjClass)
+    Expression,
+    RawExpression,
+    RawStatement,
+    TemplateArguments,
+    StructInitializer,
+    ArrayInitializer,
+    safe_exp,
+    Statement,
+    LineComment,
+    progmem_array,
+    static_const_array,
+    statement,
+    variable,
+    new_variable,
+    Pvariable,
+    new_Pvariable,
+    add,
+    add_global,
+    add_library,
+    add_build_flag,
+    add_define,
+    get_variable,
+    get_variable_with_full_id,
+    process_lambda,
+    is_template,
+    templatable,
+    MockObj,
+    MockObjClass,
+)
 from esphome.cpp_helpers import (  # noqa
-    gpio_pin_expression, register_component, build_registry_entry,
-    build_registry_list, extract_registry_entry_config, register_parented)
+    gpio_pin_expression,
+    register_component,
+    build_registry_entry,
+    build_registry_list,
+    extract_registry_entry_config,
+    register_parented,
+)
 from esphome.cpp_types import (  # noqa
-    global_ns, void, nullptr, float_, double, bool_, int_, std_ns, std_string,
-    std_vector, uint8, uint16, uint32, int32, const_char_ptr, NAN,
-    esphome_ns, App, Nameable, Component, ComponentPtr,
-    PollingComponent, Application, optional, arduino_json_ns, JsonObject,
-    JsonObjectRef, JsonObjectConstRef, Controller, GPIOPin)
+    global_ns,
+    void,
+    nullptr,
+    float_,
+    double,
+    bool_,
+    int_,
+    std_ns,
+    std_string,
+    std_vector,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    int32,
+    const_char_ptr,
+    NAN,
+    esphome_ns,
+    App,
+    Nameable,
+    Component,
+    ComponentPtr,
+    PollingComponent,
+    Application,
+    optional,
+    arduino_json_ns,
+    JsonObject,
+    JsonObjectRef,
+    JsonObjectConstRef,
+    Controller,
+    GPIOPin,
+)

esphome/components/a4988/a4988.cpp

@@ -4,13 +4,14 @@
 namespace esphome {
 namespace a4988 {
 
-static const char *TAG = "a4988.stepper";
+static const char *const TAG = "a4988.stepper";
 
 void A4988::setup() {
   ESP_LOGCONFIG(TAG, "Setting up A4988...");
   if (this->sleep_pin_ != nullptr) {
     this->sleep_pin_->setup();
     this->sleep_pin_->digital_write(false);
+    this->sleep_pin_state_ = false;
   }
   this->step_pin_->setup();
   this->step_pin_->digital_write(false);
@@ -27,7 +28,12 @@ void A4988::dump_config() {
 void A4988::loop() {
   bool at_target = this->has_reached_target();
   if (this->sleep_pin_ != nullptr) {
+    bool sleep_rising_edge = !sleep_pin_state_ & !at_target;
     this->sleep_pin_->digital_write(!at_target);
+    this->sleep_pin_state_ = !at_target;
+    if (sleep_rising_edge) {
+      delayMicroseconds(1000);
+    }
   }
   if (at_target) {
     this->high_freq_.stop();

esphome/components/a4988/a4988.h

@@ -21,6 +21,7 @@ class A4988 : public stepper::Stepper, public Component {
   GPIOPin *step_pin_;
   GPIOPin *dir_pin_;
   GPIOPin *sleep_pin_{nullptr};
+  bool sleep_pin_state_;
   HighFrequencyLoopRequester high_freq_;
 };
 

esphome/components/a4988/stepper.py

@@ -5,27 +5,29 @@ import esphome.codegen as cg
 from esphome.const import CONF_DIR_PIN, CONF_ID, CONF_SLEEP_PIN, CONF_STEP_PIN
 
 
-a4988_ns = cg.esphome_ns.namespace('a4988')
-A4988 = a4988_ns.class_('A4988', stepper.Stepper, cg.Component)
+a4988_ns = cg.esphome_ns.namespace("a4988")
+A4988 = a4988_ns.class_("A4988", stepper.Stepper, cg.Component)
 
-CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend({
-    cv.Required(CONF_ID): cv.declare_id(A4988),
-    cv.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
-    cv.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
-    cv.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = stepper.STEPPER_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(A4988),
+        cv.Required(CONF_STEP_PIN): pins.gpio_output_pin_schema,
+        cv.Required(CONF_DIR_PIN): pins.gpio_output_pin_schema,
+        cv.Optional(CONF_SLEEP_PIN): pins.gpio_output_pin_schema,
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield stepper.register_stepper(var, config)
+    await cg.register_component(var, config)
+    await stepper.register_stepper(var, config)
 
-    step_pin = yield cg.gpio_pin_expression(config[CONF_STEP_PIN])
+    step_pin = await cg.gpio_pin_expression(config[CONF_STEP_PIN])
     cg.add(var.set_step_pin(step_pin))
-    dir_pin = yield cg.gpio_pin_expression(config[CONF_DIR_PIN])
+    dir_pin = await cg.gpio_pin_expression(config[CONF_DIR_PIN])
     cg.add(var.set_dir_pin(dir_pin))
 
     if CONF_SLEEP_PIN in config:
-        sleep_pin = yield cg.gpio_pin_expression(config[CONF_SLEEP_PIN])
+        sleep_pin = await cg.gpio_pin_expression(config[CONF_SLEEP_PIN])
         cg.add(var.set_sleep_pin(sleep_pin))

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -9,15 +9,15 @@
 namespace esphome {
 namespace ac_dimmer {
 
-static const char *TAG = "ac_dimmer";
+static const char *const TAG = "ac_dimmer";
 
 // Global array to store dimmer objects
-static AcDimmerDataStore *all_dimmers[32];
+static AcDimmerDataStore *all_dimmers[32];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 /// Time in microseconds the gate should be held high
 /// 10µs should be long enough for most triacs
 /// For reference: BT136 datasheet says 2µs nominal (page 7)
-static uint32_t GATE_ENABLE_TIME = 10;
+static const uint32_t GATE_ENABLE_TIME = 10;
 
 /// Function called from timer interrupt
 /// Input is current time in microseconds (micros())
@@ -125,7 +125,7 @@ void ICACHE_RAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
 }
 
 void ICACHE_RAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store) {
-  // Attaching pin interrupts on the same pin will override the previous interupt
+  // Attaching pin interrupts on the same pin will override the previous interrupt
   // However, the user expects that multiple dimmers sharing the same ZC pin will work.
   // We solve this in a bit of a hacky way: On each pin interrupt, we check all dimmers
   // if any of them are using the same ZC pin, and also trigger the interrupt for *them*.

esphome/components/ac_dimmer/output.py

@@ -4,42 +4,46 @@ from esphome import pins
 from esphome.components import output
 from esphome.const import CONF_ID, CONF_MIN_POWER, CONF_METHOD
 
-CODEOWNERS = ['@glmnet']
+CODEOWNERS = ["@glmnet"]
 
-ac_dimmer_ns = cg.esphome_ns.namespace('ac_dimmer')
-AcDimmer = ac_dimmer_ns.class_('AcDimmer', output.FloatOutput, cg.Component)
+ac_dimmer_ns = cg.esphome_ns.namespace("ac_dimmer")
+AcDimmer = ac_dimmer_ns.class_("AcDimmer", output.FloatOutput, cg.Component)
 
-DimMethod = ac_dimmer_ns.enum('DimMethod')
+DimMethod = ac_dimmer_ns.enum("DimMethod")
 DIM_METHODS = {
-    'LEADING_PULSE': DimMethod.DIM_METHOD_LEADING_PULSE,
-    'LEADING': DimMethod.DIM_METHOD_LEADING,
-    'TRAILING': DimMethod.DIM_METHOD_TRAILING,
+    "LEADING_PULSE": DimMethod.DIM_METHOD_LEADING_PULSE,
+    "LEADING": DimMethod.DIM_METHOD_LEADING,
+    "TRAILING": DimMethod.DIM_METHOD_TRAILING,
 }
 
-CONF_GATE_PIN = 'gate_pin'
-CONF_ZERO_CROSS_PIN = 'zero_cross_pin'
-CONF_INIT_WITH_HALF_CYCLE = 'init_with_half_cycle'
-CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
-    cv.Required(CONF_ID): cv.declare_id(AcDimmer),
-    cv.Required(CONF_GATE_PIN): pins.internal_gpio_output_pin_schema,
-    cv.Required(CONF_ZERO_CROSS_PIN): pins.internal_gpio_input_pin_schema,
-    cv.Optional(CONF_INIT_WITH_HALF_CYCLE, default=True): cv.boolean,
-    cv.Optional(CONF_METHOD, default='leading pulse'): cv.enum(DIM_METHODS, upper=True, space='_'),
-}).extend(cv.COMPONENT_SCHEMA)
+CONF_GATE_PIN = "gate_pin"
+CONF_ZERO_CROSS_PIN = "zero_cross_pin"
+CONF_INIT_WITH_HALF_CYCLE = "init_with_half_cycle"
+CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(AcDimmer),
+        cv.Required(CONF_GATE_PIN): pins.internal_gpio_output_pin_schema,
+        cv.Required(CONF_ZERO_CROSS_PIN): pins.internal_gpio_input_pin_schema,
+        cv.Optional(CONF_INIT_WITH_HALF_CYCLE, default=True): cv.boolean,
+        cv.Optional(CONF_METHOD, default="leading pulse"): cv.enum(
+            DIM_METHODS, upper=True, space="_"
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
+    await cg.register_component(var, config)
 
     # override default min power to 10%
     if CONF_MIN_POWER not in config:
         config[CONF_MIN_POWER] = 0.1
-    yield output.register_output(var, config)
+    await output.register_output(var, config)
 
-    pin = yield cg.gpio_pin_expression(config[CONF_GATE_PIN])
+    pin = await cg.gpio_pin_expression(config[CONF_GATE_PIN])
     cg.add(var.set_gate_pin(pin))
-    pin = yield cg.gpio_pin_expression(config[CONF_ZERO_CROSS_PIN])
+    pin = await cg.gpio_pin_expression(config[CONF_ZERO_CROSS_PIN])
     cg.add(var.set_zero_cross_pin(pin))
     cg.add(var.set_init_with_half_cycle(config[CONF_INIT_WITH_HALF_CYCLE]))
     cg.add(var.set_method(config[CONF_METHOD]))

esphome/components/adalight/__init__.py

@@ -5,20 +5,23 @@ from esphome.components.light.types import AddressableLightEffect
 from esphome.components.light.effects import register_addressable_effect
 from esphome.const import CONF_NAME, CONF_UART_ID
 
-DEPENDENCIES = ['uart']
+DEPENDENCIES = ["uart"]
 
-adalight_ns = cg.esphome_ns.namespace('adalight')
+adalight_ns = cg.esphome_ns.namespace("adalight")
 AdalightLightEffect = adalight_ns.class_(
-    'AdalightLightEffect', uart.UARTDevice, AddressableLightEffect)
+    "AdalightLightEffect", uart.UARTDevice, AddressableLightEffect
+)
 
 CONFIG_SCHEMA = cv.Schema({})
 
 
-@register_addressable_effect('adalight', AdalightLightEffect, "Adalight", {
-    cv.GenerateID(CONF_UART_ID): cv.use_id(uart.UARTComponent)
-})
-def adalight_light_effect_to_code(config, effect_id):
+@register_addressable_effect(
+    "adalight",
+    AdalightLightEffect,
+    "Adalight",
+    {cv.GenerateID(CONF_UART_ID): cv.use_id(uart.UARTComponent)},
+)
+async def adalight_light_effect_to_code(config, effect_id):
     effect = cg.new_Pvariable(effect_id, config[CONF_NAME])
-    yield uart.register_uart_device(effect, config)
-
-    yield effect
+    await uart.register_uart_device(effect, config)
+    return effect

esphome/components/adalight/adalight_light_effect.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace adalight {
 
-static const char *TAG = "adalight_light_effect";
+static const char *const TAG = "adalight_light_effect";
 
 static const uint32_t ADALIGHT_ACK_INTERVAL = 1000;
 static const uint32_t ADALIGHT_RECEIVE_TIMEOUT = 1000;
@@ -42,11 +42,11 @@ void AdalightLightEffect::reset_frame_(light::AddressableLight &it) {
 
 void AdalightLightEffect::blank_all_leds_(light::AddressableLight &it) {
   for (int led = it.size(); led-- > 0;) {
-    it[led].set(light::ESPColor::BLACK);
+    it[led].set(Color::BLACK);
   }
 }
 
-void AdalightLightEffect::apply(light::AddressableLight &it, const light::ESPColor &current_color) {
+void AdalightLightEffect::apply(light::AddressableLight &it, const Color &current_color) {
   const uint32_t now = millis();
 
   if (now - this->last_ack_ >= ADALIGHT_ACK_INTERVAL) {
@@ -130,7 +130,7 @@ AdalightLightEffect::Frame AdalightLightEffect::parse_frame_(light::AddressableL
   for (int led = 0; led < accepted_led_count; led++, led_data += 3) {
     auto white = std::min(std::min(led_data[0], led_data[1]), led_data[2]);
 
-    it[led].set(light::ESPColor(led_data[0], led_data[1], led_data[2], white));
+    it[led].set(Color(led_data[0], led_data[1], led_data[2], white));
   }
 
   return CONSUMED;

esphome/components/adalight/adalight_light_effect.h

@@ -16,7 +16,7 @@ class AdalightLightEffect : public light::AddressableLightEffect, public uart::U
  public:
   void start() override;
   void stop() override;
-  void apply(light::AddressableLight &it, const light::ESPColor &current_color) override;
+  void apply(light::AddressableLight &it, const Color &current_color) override;
 
  protected:
   enum Frame {

esphome/components/adc/__init__.py

@@ -1 +1 @@
-CODEOWNERS = ['@esphome/core']
+CODEOWNERS = ["@esphome/core"]

esphome/components/adc/adc_sensor.cpp

@@ -8,18 +8,64 @@ ADC_MODE(ADC_VCC)
 namespace esphome {
 namespace adc {
 
-static const char *TAG = "adc";
+static const char *const TAG = "adc";
 
 #ifdef ARDUINO_ARCH_ESP32
-void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuation_ = attenuation; }
+void ADCSensor::set_attenuation(adc_atten_t attenuation) { this->attenuation_ = attenuation; }
+
+inline adc1_channel_t gpio_to_adc1(uint8_t pin) {
+#if CONFIG_IDF_TARGET_ESP32
+  switch (pin) {
+    case 36:
+      return ADC1_CHANNEL_0;
+    case 37:
+      return ADC1_CHANNEL_1;
+    case 38:
+      return ADC1_CHANNEL_2;
+    case 39:
+      return ADC1_CHANNEL_3;
+    case 32:
+      return ADC1_CHANNEL_4;
+    case 33:
+      return ADC1_CHANNEL_5;
+    case 34:
+      return ADC1_CHANNEL_6;
+    case 35:
+      return ADC1_CHANNEL_7;
+    default:
+      return ADC1_CHANNEL_MAX;
+  }
+#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
+  switch (pin) {
+    case 0:
+      return ADC1_CHANNEL_0;
+    case 1:
+      return ADC1_CHANNEL_1;
+    case 2:
+      return ADC1_CHANNEL_2;
+    case 3:
+      return ADC1_CHANNEL_3;
+    case 4:
+      return ADC1_CHANNEL_4;
+    default:
+      return ADC1_CHANNEL_MAX;
+  }
+#endif
+}
 #endif
 
 void ADCSensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
+#ifndef USE_ADC_SENSOR_VCC
   GPIOPin(this->pin_, INPUT).setup();
+#endif
 
 #ifdef ARDUINO_ARCH_ESP32
-  analogSetPinAttenuation(this->pin_, this->attenuation_);
+  adc1_config_channel_atten(gpio_to_adc1(pin_), attenuation_);
+  adc1_config_width(ADC_WIDTH_BIT_12);
+#if !CONFIG_IDF_TARGET_ESP32C3 && !CONFIG_IDF_TARGET_ESP32H2
+  adc_gpio_init(ADC_UNIT_1, (adc_channel_t) gpio_to_adc1(pin_));
+#endif
 #endif
 }
 void ADCSensor::dump_config() {
@@ -34,18 +80,20 @@ void ADCSensor::dump_config() {
 #ifdef ARDUINO_ARCH_ESP32
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
 #endif
   LOG_UPDATE_INTERVAL(this);
@@ -58,21 +106,43 @@ void ADCSensor::update() {
 }
 float ADCSensor::sample() {
 #ifdef ARDUINO_ARCH_ESP32
-  float value_v = analogRead(this->pin_) / 4095.0f;  // NOLINT
+  int raw = adc1_get_raw(gpio_to_adc1(pin_));
+  float value_v = raw / 4095.0f;
+#if CONFIG_IDF_TARGET_ESP32
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       value_v *= 1.1;
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       value_v *= 1.5;
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       value_v *= 2.2;
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       value_v *= 3.9;
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
+#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
+  switch (this->attenuation_) {
+    case ADC_ATTEN_DB_0:
+      value_v *= 0.84;
+      break;
+    case ADC_ATTEN_DB_2_5:
+      value_v *= 1.13;
+      break;
+    case ADC_ATTEN_DB_6:
+      value_v *= 1.56;
+      break;
+    case ADC_ATTEN_DB_11:
+      value_v *= 3.0;
+      break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
+  }
+#endif
   return value_v;
 #endif
 

esphome/components/adc/adc_sensor.h

@@ -6,6 +6,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/voltage_sampler/voltage_sampler.h"
 
+#ifdef ARDUINO_ARCH_ESP32
+#include "driver/adc.h"
+#endif
+
 namespace esphome {
 namespace adc {
 
@@ -13,7 +17,7 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
  public:
 #ifdef ARDUINO_ARCH_ESP32
   /// Set the attenuation for this pin. Only available on the ESP32.
-  void set_attenuation(adc_attenuation_t attenuation);
+  void set_attenuation(adc_atten_t attenuation);
 #endif
 
   /// Update adc values.
@@ -34,7 +38,7 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   uint8_t pin_;
 
 #ifdef ARDUINO_ARCH_ESP32
-  adc_attenuation_t attenuation_{ADC_0db};
+  adc_atten_t attenuation_{ADC_ATTEN_DB_0};
 #endif
 };
 

esphome/components/adc/sensor.py

@@ -2,45 +2,65 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
 from esphome.components import sensor, voltage_sampler
-from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_PIN, ICON_FLASH, UNIT_VOLT
+from esphome.const import (
+    CONF_ATTENUATION,
+    CONF_ID,
+    CONF_PIN,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+)
 
 
-AUTO_LOAD = ['voltage_sampler']
+AUTO_LOAD = ["voltage_sampler"]
 
 ATTENUATION_MODES = {
-    '0db': cg.global_ns.ADC_0db,
-    '2.5db': cg.global_ns.ADC_2_5db,
-    '6db': cg.global_ns.ADC_6db,
-    '11db': cg.global_ns.ADC_11db,
+    "0db": cg.global_ns.ADC_ATTEN_DB_0,
+    "2.5db": cg.global_ns.ADC_ATTEN_DB_2_5,
+    "6db": cg.global_ns.ADC_ATTEN_DB_6,
+    "11db": cg.global_ns.ADC_ATTEN_DB_11,
 }
 
 
 def validate_adc_pin(value):
     vcc = str(value).upper()
-    if vcc == 'VCC':
+    if vcc == "VCC":
         return cv.only_on_esp8266(vcc)
     return pins.analog_pin(value)
 
 
-adc_ns = cg.esphome_ns.namespace('adc')
-ADCSensor = adc_ns.class_('ADCSensor', sensor.Sensor, cg.PollingComponent,
-                          voltage_sampler.VoltageSampler)
+adc_ns = cg.esphome_ns.namespace("adc")
+ADCSensor = adc_ns.class_(
+    "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)
 
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2).extend({
-    cv.GenerateID(): cv.declare_id(ADCSensor),
-    cv.Required(CONF_PIN): validate_adc_pin,
-    cv.SplitDefault(CONF_ATTENUATION, esp32='0db'):
-        cv.All(cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)),
-}).extend(cv.polling_component_schema('60s'))
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        unit_of_measurement=UNIT_VOLT,
+        accuracy_decimals=2,
+        device_class=DEVICE_CLASS_VOLTAGE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(ADCSensor),
+            cv.Required(CONF_PIN): validate_adc_pin,
+            cv.SplitDefault(CONF_ATTENUATION, esp32="0db"): cv.All(
+                cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
 
-    if config[CONF_PIN] == 'VCC':
-        cg.add_define('USE_ADC_SENSOR_VCC')
+    if config[CONF_PIN] == "VCC":
+        cg.add_define("USE_ADC_SENSOR_VCC")
     else:
         cg.add(var.set_pin(config[CONF_PIN]))
 

esphome/components/addressable_light/addressable_light_display.cpp

@@ -0,0 +1,67 @@
+#include "addressable_light_display.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace addressable_light {
+
+static const char *const TAG = "addressable_light.display";
+
+int AddressableLightDisplay::get_width_internal() { return this->width_; }
+int AddressableLightDisplay::get_height_internal() { return this->height_; }
+
+void AddressableLightDisplay::setup() {
+  this->addressable_light_buffer_.resize(this->width_ * this->height_, {0, 0, 0, 0});
+}
+
+void AddressableLightDisplay::update() {
+  if (!this->enabled_)
+    return;
+
+  this->do_update_();
+  this->display();
+}
+
+void AddressableLightDisplay::display() {
+  bool dirty = false;
+  uint8_t old_r, old_g, old_b, old_w;
+  Color *c;
+
+  for (uint32_t offset = 0; offset < this->addressable_light_buffer_.size(); offset++) {
+    c = &(this->addressable_light_buffer_[offset]);
+
+    light::ESPColorView pixel = (*this->light_)[offset];
+
+    // Track the original values for the pixel view. If it has changed updating, then
+    // we trigger a redraw. Avoiding redraws == avoiding flicker!
+    old_r = pixel.get_red();
+    old_g = pixel.get_green();
+    old_b = pixel.get_blue();
+    old_w = pixel.get_white();
+
+    pixel.set_rgbw(c->r, c->g, c->b, c->w);
+
+    // If the actual value of the pixel changed, then schedule a redraw.
+    if (pixel.get_red() != old_r || pixel.get_green() != old_g || pixel.get_blue() != old_b ||
+        pixel.get_white() != old_w) {
+      dirty = true;
+    }
+  }
+
+  if (dirty) {
+    this->light_->schedule_show();
+  }
+}
+
+void HOT AddressableLightDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
+  if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0)
+    return;
+
+  if (this->pixel_mapper_f_.has_value()) {
+    // Params are passed by reference, so they may be modified in call.
+    this->addressable_light_buffer_[(*this->pixel_mapper_f_)(x, y)] = color;
+  } else {
+    this->addressable_light_buffer_[y * this->get_width_internal() + x] = color;
+  }
+}
+}  // namespace addressable_light
+}  // namespace esphome

esphome/components/addressable_light/addressable_light_display.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/color.h"
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/light/addressable_light.h"
+
+namespace esphome {
+namespace addressable_light {
+
+class AddressableLightDisplay : public display::DisplayBuffer, public PollingComponent {
+ public:
+  light::AddressableLight *get_light() const { return this->light_; }
+
+  void set_width(int32_t width) { width_ = width; }
+  void set_height(int32_t height) { height_ = height; }
+  void set_light(light::LightState *state) {
+    light_state_ = state;
+    light_ = static_cast<light::AddressableLight *>(state->get_output());
+  }
+  void set_enabled(bool enabled) {
+    if (light_state_) {
+      if (enabled_ && !enabled) {  // enabled -> disabled
+        // - Tell the parent light to refresh, effectively wiping the display. Also
+        //   restores the previous effect (if any).
+        light_state_->make_call().set_effect(this->last_effect_).perform();
+
+      } else if (!enabled_ && enabled) {  // disabled -> enabled
+        // - Save the current effect.
+        this->last_effect_ = light_state_->get_effect_name();
+        // - Disable any current effect.
+        light_state_->make_call().set_effect(0).perform();
+      }
+    }
+    enabled_ = enabled;
+  }
+  bool get_enabled() { return enabled_; }
+
+  void set_pixel_mapper(std::function<int(int, int)> &&pixel_mapper_f) { this->pixel_mapper_f_ = pixel_mapper_f; }
+  void setup() override;
+  void display();
+
+ protected:
+  int get_width_internal() override;
+  int get_height_internal() override;
+  void draw_absolute_pixel_internal(int x, int y, Color color) override;
+  void update() override;
+
+  light::LightState *light_state_;
+  light::AddressableLight *light_;
+  bool enabled_{true};
+  int32_t width_;
+  int32_t height_;
+  std::vector<Color> addressable_light_buffer_;
+  optional<std::string> last_effect_;
+  optional<std::function<int(int, int)>> pixel_mapper_f_;
+};
+}  // namespace addressable_light
+}  // namespace esphome

esphome/components/addressable_light/display.py

@@ -0,0 +1,63 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import display, light
+from esphome.const import (
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_PAGES,
+    CONF_ADDRESSABLE_LIGHT_ID,
+    CONF_HEIGHT,
+    CONF_WIDTH,
+    CONF_UPDATE_INTERVAL,
+    CONF_PIXEL_MAPPER,
+)
+
+CODEOWNERS = ["@justfalter"]
+
+addressable_light_ns = cg.esphome_ns.namespace("addressable_light")
+AddressableLightDisplay = addressable_light_ns.class_(
+    "AddressableLightDisplay", display.DisplayBuffer, cg.PollingComponent
+)
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(AddressableLightDisplay),
+            cv.Required(CONF_ADDRESSABLE_LIGHT_ID): cv.use_id(
+                light.AddressableLightState
+            ),
+            cv.Required(CONF_WIDTH): cv.positive_int,
+            cv.Required(CONF_HEIGHT): cv.positive_int,
+            cv.Optional(
+                CONF_UPDATE_INTERVAL, default="16ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_PIXEL_MAPPER): cv.returning_lambda,
+        }
+    ),
+    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    wrapped_light = await cg.get_variable(config[CONF_ADDRESSABLE_LIGHT_ID])
+    cg.add(var.set_width(config[CONF_WIDTH]))
+    cg.add(var.set_height(config[CONF_HEIGHT]))
+    cg.add(var.set_light(wrapped_light))
+
+    await cg.register_component(var, config)
+    await display.register_display(var, config)
+
+    if CONF_PIXEL_MAPPER in config:
+        pixel_mapper_template_ = await cg.process_lambda(
+            config[CONF_PIXEL_MAPPER],
+            [(int, "x"), (int, "y")],
+            return_type=cg.int_,
+        )
+        cg.add(var.set_pixel_mapper(pixel_mapper_template_))
+
+    if CONF_LAMBDA in config:
+        lambda_ = await cg.process_lambda(
+            config[CONF_LAMBDA], [(display.DisplayBufferRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))

esphome/components/ade7953/ade7953.cpp

@@ -4,10 +4,13 @@
 namespace esphome {
 namespace ade7953 {
 
-static const char *TAG = "ade7953";
+static const char *const TAG = "ade7953";
 
 void ADE7953::dump_config() {
   ESP_LOGCONFIG(TAG, "ADE7953:");
+  if (this->has_irq_) {
+    ESP_LOGCONFIG(TAG, "  IRQ Pin: GPIO%u", this->irq_pin_number_);
+  }
   LOG_I2C_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Voltage Sensor", this->voltage_sensor_);
@@ -18,8 +21,8 @@ void ADE7953::dump_config() {
 }
 
 #define ADE_PUBLISH_(name, factor) \
-  if (name && this->name##_sensor_) { \
-    float value = *name / factor; \
+  if ((name) && this->name##_sensor_) { \
+    float value = *(name) / (factor); \
     this->name##_sensor_->publish_state(value); \
   }
 #define ADE_PUBLISH(name, factor) ADE_PUBLISH_(name, factor)

esphome/components/ade7953/ade7953.h

@@ -9,6 +9,10 @@ namespace ade7953 {
 
 class ADE7953 : public i2c::I2CDevice, public PollingComponent {
  public:
+  void set_irq_pin(uint8_t irq_pin) {
+    has_irq_ = true;
+    irq_pin_number_ = irq_pin;
+  }
   void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
   void set_current_a_sensor(sensor::Sensor *current_a_sensor) { current_a_sensor_ = current_a_sensor; }
   void set_current_b_sensor(sensor::Sensor *current_b_sensor) { current_b_sensor_ = current_b_sensor; }
@@ -20,6 +24,11 @@ class ADE7953 : public i2c::I2CDevice, public PollingComponent {
   }
 
   void setup() override {
+    if (this->has_irq_) {
+      auto pin = GPIOPin(this->irq_pin_number_, INPUT);
+      this->irq_pin_ = &pin;
+      this->irq_pin_->setup();
+    }
     this->set_timeout(100, [this]() {
       this->ade_write_<uint8_t>(0x0010, 0x04);
       this->ade_write_<uint8_t>(0x00FE, 0xAD);
@@ -55,6 +64,9 @@ class ADE7953 : public i2c::I2CDevice, public PollingComponent {
     return result;
   }
 
+  bool has_irq_ = false;
+  uint8_t irq_pin_number_;
+  GPIOPin *irq_pin_{nullptr};
   bool is_setup_{false};
   sensor::Sensor *voltage_sensor_{nullptr};
   sensor::Sensor *current_a_sensor_{nullptr};

esphome/components/ade7953/sensor.py

@@ -1,39 +1,89 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, i2c
-from esphome.const import CONF_ID, CONF_VOLTAGE, \
-    UNIT_VOLT, ICON_FLASH, UNIT_AMPERE, UNIT_WATT
+from esphome import pins
+from esphome.const import (
+    CONF_ID,
+    CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-ace7953_ns = cg.esphome_ns.namespace('ade7953')
-ADE7953 = ace7953_ns.class_('ADE7953', cg.PollingComponent, i2c.I2CDevice)
+ade7953_ns = cg.esphome_ns.namespace("ade7953")
+ADE7953 = ade7953_ns.class_("ADE7953", cg.PollingComponent, i2c.I2CDevice)
 
-CONF_CURRENT_A = 'current_a'
-CONF_CURRENT_B = 'current_b'
-CONF_ACTIVE_POWER_A = 'active_power_a'
-CONF_ACTIVE_POWER_B = 'active_power_b'
+CONF_IRQ_PIN = "irq_pin"
+CONF_CURRENT_A = "current_a"
+CONF_CURRENT_B = "current_b"
+CONF_ACTIVE_POWER_A = "active_power_a"
+CONF_ACTIVE_POWER_B = "active_power_b"
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ADE7953),
-
-    cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
-    cv.Optional(CONF_CURRENT_A): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
-    cv.Optional(CONF_CURRENT_B): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
-    cv.Optional(CONF_ACTIVE_POWER_A): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
-    cv.Optional(CONF_ACTIVE_POWER_B): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x38))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ADE7953),
+            cv.Optional(CONF_IRQ_PIN): pins.input_pin,
+            cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT_A): sensor.sensor_schema(
+                unit_of_measurement=UNIT_AMPERE,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT_B): sensor.sensor_schema(
+                unit_of_measurement=UNIT_AMPERE,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_CURRENT,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_A): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_B): sensor.sensor_schema(
+                unit_of_measurement=UNIT_WATT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_POWER,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
-    for key in [CONF_VOLTAGE, CONF_CURRENT_A, CONF_CURRENT_B, CONF_ACTIVE_POWER_A,
-                CONF_ACTIVE_POWER_B]:
+    if CONF_IRQ_PIN in config:
+        cg.add(var.set_irq_pin(config[CONF_IRQ_PIN]))
+
+    for key in [
+        CONF_VOLTAGE,
+        CONF_CURRENT_A,
+        CONF_CURRENT_B,
+        CONF_ACTIVE_POWER_A,
+        CONF_ACTIVE_POWER_B,
+    ]:
         if key not in config:
             continue
         conf = config[key]
-        sens = yield sensor.new_sensor(conf)
-        cg.add(getattr(var, f'set_{key}_sensor')(sens))
+        sens = await sensor.new_sensor(conf)
+        cg.add(getattr(var, f"set_{key}_sensor")(sens))

esphome/components/ads1115/__init__.py

@@ -3,23 +3,29 @@ import esphome.config_validation as cv
 from esphome.components import i2c
 from esphome.const import CONF_ID
 
-DEPENDENCIES = ['i2c']
-AUTO_LOAD = ['sensor', 'voltage_sampler']
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensor", "voltage_sampler"]
 MULTI_CONF = True
 
-ads1115_ns = cg.esphome_ns.namespace('ads1115')
-ADS1115Component = ads1115_ns.class_('ADS1115Component', cg.Component, i2c.I2CDevice)
+ads1115_ns = cg.esphome_ns.namespace("ads1115")
+ADS1115Component = ads1115_ns.class_("ADS1115Component", cg.Component, i2c.I2CDevice)
 
-CONF_CONTINUOUS_MODE = 'continuous_mode'
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ADS1115Component),
-    cv.Optional(CONF_CONTINUOUS_MODE, default=False): cv.boolean,
-}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(None))
+CONF_CONTINUOUS_MODE = "continuous_mode"
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1115Component),
+            cv.Optional(CONF_CONTINUOUS_MODE, default=False): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(None))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     cg.add(var.set_continuous_mode(config[CONF_CONTINUOUS_MODE]))

esphome/components/ads1115/ads1115.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace ads1115 {
 
-static const char *TAG = "ads1115";
+static const char *const TAG = "ads1115";
 static const uint8_t ADS1115_REGISTER_CONVERSION = 0x00;
 static const uint8_t ADS1115_REGISTER_CONFIG = 0x01;
 
@@ -64,11 +64,6 @@ void ADS1115Component::setup() {
     return;
   }
   this->prev_config_ = config;
-
-  for (auto *sensor : this->sensors_) {
-    this->set_interval(sensor->get_name(), sensor->update_interval(),
-                       [this, sensor] { this->request_measurement(sensor); });
-  }
 }
 void ADS1115Component::dump_config() {
   ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
@@ -107,17 +102,22 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
     }
     this->prev_config_ = config;
 
-    // about 1.6 ms with 860 samples per second
+    // about 1.2 ms with 860 samples per second
     delay(2);
 
-    uint32_t start = millis();
-    while (this->read_byte_16(ADS1115_REGISTER_CONFIG, &config) && (config >> 15) == 0) {
-      if (millis() - start > 100) {
-        ESP_LOGW(TAG, "Reading ADS1115 timed out");
-        this->status_set_warning();
-        return NAN;
+    // in continuous mode, conversion will always be running, rely on the delay
+    // to ensure conversion is taking place with the correct settings
+    // can we use the rdy pin to trigger when a conversion is done?
+    if (!this->continuous_mode_) {
+      uint32_t start = millis();
+      while (this->read_byte_16(ADS1115_REGISTER_CONFIG, &config) && (config >> 15) == 0) {
+        if (millis() - start > 100) {
+          ESP_LOGW(TAG, "Reading ADS1115 timed out");
+          this->status_set_warning();
+          return NAN;
+        }
+        yield();
       }
-      yield();
     }
   }
 

esphome/components/ads1115/sensor.py

@@ -1,60 +1,79 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, voltage_sampler
-from esphome.const import CONF_GAIN, CONF_MULTIPLEXER, ICON_FLASH, UNIT_VOLT, CONF_ID
+from esphome.const import (
+    CONF_GAIN,
+    CONF_MULTIPLEXER,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+    CONF_ID,
+)
 from . import ads1115_ns, ADS1115Component
 
-DEPENDENCIES = ['ads1115']
+DEPENDENCIES = ["ads1115"]
 
-ADS1115Multiplexer = ads1115_ns.enum('ADS1115Multiplexer')
+ADS1115Multiplexer = ads1115_ns.enum("ADS1115Multiplexer")
 MUX = {
-    'A0_A1': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
-    'A0_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
-    'A1_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
-    'A2_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
-    'A0_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
-    'A1_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
-    'A2_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
-    'A3_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
+    "A0_A1": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
+    "A0_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
+    "A1_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
+    "A2_A3": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
+    "A0_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
+    "A1_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
+    "A2_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
+    "A3_GND": ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
 }
 
-ADS1115Gain = ads1115_ns.enum('ADS1115Gain')
+ADS1115Gain = ads1115_ns.enum("ADS1115Gain")
 GAIN = {
-    '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
-    '4.096': ADS1115Gain.ADS1115_GAIN_4P096,
-    '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
-    '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
-    '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
-    '0.256': ADS1115Gain.ADS1115_GAIN_0P256,
+    "6.144": ADS1115Gain.ADS1115_GAIN_6P144,
+    "4.096": ADS1115Gain.ADS1115_GAIN_4P096,
+    "2.048": ADS1115Gain.ADS1115_GAIN_2P048,
+    "1.024": ADS1115Gain.ADS1115_GAIN_1P024,
+    "0.512": ADS1115Gain.ADS1115_GAIN_0P512,
+    "0.256": ADS1115Gain.ADS1115_GAIN_0P256,
 }
 
 
 def validate_gain(value):
     if isinstance(value, float):
-        value = f'{value:0.03f}'
+        value = f"{value:0.03f}"
     elif not isinstance(value, str):
         raise cv.Invalid(f'invalid gain "{value}"')
 
     return cv.enum(GAIN)(value)
 
 
-ADS1115Sensor = ads1115_ns.class_('ADS1115Sensor', sensor.Sensor, cg.PollingComponent,
-                                  voltage_sampler.VoltageSampler)
+ADS1115Sensor = ads1115_ns.class_(
+    "ADS1115Sensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)
 
-CONF_ADS1115_ID = 'ads1115_id'
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 3).extend({
-    cv.GenerateID(): cv.declare_id(ADS1115Sensor),
-    cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
-    cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space='_'),
-    cv.Required(CONF_GAIN): validate_gain,
-}).extend(cv.polling_component_schema('60s'))
+CONF_ADS1115_ID = "ads1115_id"
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        unit_of_measurement=UNIT_VOLT,
+        accuracy_decimals=3,
+        device_class=DEVICE_CLASS_VOLTAGE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1115Sensor),
+            cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
+            cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space="_"),
+            cv.Required(CONF_GAIN): validate_gain,
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+)
 
 
-def to_code(config):
-    paren = yield cg.get_variable(config[CONF_ADS1115_ID])
+async def to_code(config):
+    paren = await cg.get_variable(config[CONF_ADS1115_ID])
     var = cg.new_Pvariable(config[CONF_ID], paren)
-    yield sensor.register_sensor(var, config)
-    yield cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
 
     cg.add(var.set_multiplexer(config[CONF_MULTIPLEXER]))
     cg.add(var.set_gain(config[CONF_GAIN]))

esphome/components/aht10/aht10.cpp

@@ -10,7 +10,7 @@
 //
 // According to the datasheet, the component is supposed to respond in more than 75ms. In fact, it can answer almost
 // immediately for temperature. But for humidity, it takes >90ms to get a valid data. From experience, we have best
-// results making successive requests; the current implementation make 3 attemps with a delay of 30ms each time.
+// results making successive requests; the current implementation makes 3 attempts with a delay of 30ms each time.
 
 #include "aht10.h"
 #include "esphome/core/log.h"
@@ -18,12 +18,12 @@
 namespace esphome {
 namespace aht10 {
 
-static const char *TAG = "aht10";
+static const char *const TAG = "aht10";
 static const uint8_t AHT10_CALIBRATE_CMD[] = {0xE1};
 static const uint8_t AHT10_MEASURE_CMD[] = {0xAC, 0x33, 0x00};
 static const uint8_t AHT10_DEFAULT_DELAY = 5;    // ms, for calibration and temperature measurement
 static const uint8_t AHT10_HUMIDITY_DELAY = 30;  // ms
-static const uint8_t AHT10_ATTEMPS = 3;          // safety margin, normally 3 attemps are enough: 3*30=90ms
+static const uint8_t AHT10_ATTEMPTS = 3;         // safety margin, normally 3 attempts are enough: 3*30=90ms
 
 void AHT10Component::setup() {
   ESP_LOGCONFIG(TAG, "Setting up AHT10...");
@@ -58,8 +58,9 @@ void AHT10Component::update() {
   uint8_t delay = AHT10_DEFAULT_DELAY;
   if (this->humidity_sensor_ != nullptr)
     delay = AHT10_HUMIDITY_DELAY;
-  for (int i = 0; i < AHT10_ATTEMPS; ++i) {
-    ESP_LOGVV(TAG, "Attemps %u at %6ld", i, millis());
+  for (int i = 0; i < AHT10_ATTEMPTS; ++i) {
+    ESP_LOGVV(TAG, "Attempt %u at %6ld", i, millis());
+    delay_microseconds_accurate(4);
     if (!this->read_bytes(0, data, 6, delay)) {
       ESP_LOGD(TAG, "Communication with AHT10 failed, waiting...");
     } else if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy

esphome/components/aht10/sensor.py

@@ -1,30 +1,54 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-aht10_ns = cg.esphome_ns.namespace('aht10')
-AHT10Component = aht10_ns.class_('AHT10Component', cg.PollingComponent, i2c.I2CDevice)
+aht10_ns = cg.esphome_ns.namespace("aht10")
+AHT10Component = aht10_ns.class_("AHT10Component", cg.PollingComponent, i2c.I2CDevice)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AHT10Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 2),
-    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 2),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x38))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AHT10Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
-        sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
         cg.add(var.set_temperature_sensor(sens))
 
     if CONF_HUMIDITY in config:
-        sens = yield sensor.new_sensor(config[CONF_HUMIDITY])
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
         cg.add(var.set_humidity_sensor(sens))

esphome/components/am2320/am2320.cpp

@@ -9,7 +9,7 @@
 namespace esphome {
 namespace am2320 {
 
-static const char *TAG = "am2320";
+static const char *const TAG = "am2320";
 
 // ---=== Calc CRC16 ===---
 uint16_t crc_16(uint8_t *ptr, uint8_t length) {

esphome/components/am2320/sensor.py

@@ -1,30 +1,56 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-am2320_ns = cg.esphome_ns.namespace('am2320')
-AM2320Component = am2320_ns.class_('AM2320Component', cg.PollingComponent, i2c.I2CDevice)
+am2320_ns = cg.esphome_ns.namespace("am2320")
+AM2320Component = am2320_ns.class_(
+    "AM2320Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AM2320Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
-    cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x5C))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AM2320Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x5C))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
-        sens = yield sensor.new_sensor(config[CONF_TEMPERATURE])
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
         cg.add(var.set_temperature_sensor(sens))
 
     if CONF_HUMIDITY in config:
-        sens = yield sensor.new_sensor(config[CONF_HUMIDITY])
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
         cg.add(var.set_humidity_sensor(sens))

esphome/components/am43/am43.cpp

@@ -0,0 +1,115 @@
+#include "am43.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace am43 {
+
+static const char *TAG = "am43";
+
+void Am43::dump_config() {
+  ESP_LOGCONFIG(TAG, "AM43");
+  LOG_SENSOR(" ", "Battery", this->battery_);
+  LOG_SENSOR(" ", "Illuminance", this->illuminance_);
+}
+
+void Am43::setup() {
+  this->encoder_ = new Am43Encoder();
+  this->decoder_ = new Am43Decoder();
+  this->logged_in_ = false;
+  this->last_battery_update_ = 0;
+  this->current_sensor_ = 0;
+}
+
+void Am43::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: {
+      this->logged_in_ = false;
+      break;
+    }
+    case ESP_GATTC_DISCONNECT_EVT: {
+      this->logged_in_ = false;
+      this->node_state = espbt::ClientState::Idle;
+      if (this->battery_ != nullptr)
+        this->battery_->publish_state(NAN);
+      if (this->illuminance_ != nullptr)
+        this->illuminance_->publish_state(NAN);
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      auto chr = this->parent_->get_characteristic(AM43_SERVICE_UUID, AM43_CHARACTERISTIC_UUID);
+      if (chr == nullptr) {
+        if (this->parent_->get_characteristic(AM43_TUYA_SERVICE_UUID, AM43_TUYA_CHARACTERISTIC_UUID) != nullptr) {
+          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.",
+                   this->parent_->address_str().c_str());
+        } else {
+          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?",
+                   this->parent_->address_str().c_str());
+        }
+        break;
+      }
+      this->char_handle_ = chr->handle;
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      this->node_state = espbt::ClientState::Established;
+      this->update();
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.handle != this->char_handle_)
+        break;
+      this->decoder_->decode(param->notify.value, param->notify.value_len);
+
+      if (this->battery_ != nullptr && this->decoder_->has_battery_level() &&
+          millis() - this->last_battery_update_ > 10000) {
+        this->battery_->publish_state(this->decoder_->battery_level_);
+        this->last_battery_update_ = millis();
+      }
+
+      if (this->illuminance_ != nullptr && this->decoder_->has_light_level()) {
+        this->illuminance_->publish_state(this->decoder_->light_level_);
+      }
+
+      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);
+          if (status)
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
+                     status);
+        }
+        this->current_sensor_ = 0;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void Am43::update() {
+  if (this->node_state != espbt::ClientState::Established) {
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
+    return;
+  }
+  if (this->current_sensor_ == 0) {
+    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_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    }
+    this->current_sensor_++;
+  }
+}
+
+}  // namespace am43
+}  // namespace esphome
+
+#endif

esphome/components/am43/am43.h

@@ -0,0 +1,45 @@
+#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"
+#include "esphome/components/am43/am43_base.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace am43 {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class Am43 : public esphome::ble_client::BLEClientNode, public PollingComponent {
+ public:
+  void setup() override;
+  void update() 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;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_battery(sensor::Sensor *battery) { battery_ = battery; }
+  void set_illuminance(sensor::Sensor *illuminance) { illuminance_ = illuminance; }
+
+ protected:
+  uint16_t char_handle_;
+  Am43Encoder *encoder_;
+  Am43Decoder *decoder_;
+  bool logged_in_;
+  sensor::Sensor *battery_{nullptr};
+  sensor::Sensor *illuminance_{nullptr};
+  uint8_t current_sensor_;
+  // The AM43 often gets into a state where it spams loads of battery update
+  // notifications. Here we will limit to no more than every 10s.
+  uint8_t last_battery_update_;
+};
+
+}  // namespace am43
+}  // namespace esphome
+
+#endif

esphome/components/am43/am43_base.cpp

@@ -0,0 +1,142 @@
+#include "am43_base.h"
+
+namespace esphome {
+namespace am43 {
+
+const uint8_t START_PACKET[5] = {0x00, 0xff, 0x00, 0x00, 0x9a};
+
+std::string pkt_to_hex(const uint8_t *data, uint16_t len) {
+  char buf[64];
+  memset(buf, 0, 64);
+  for (int i = 0; i < len; i++)
+    sprintf(&buf[i * 2], "%02x", data[i]);
+  std::string ret = buf;
+  return ret;
+}
+
+Am43Packet *Am43Encoder::get_battery_level_request() {
+  uint8_t data = 0x1;
+  return this->encode_(0xA2, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_light_level_request() {
+  uint8_t data = 0x1;
+  return this->encode_(0xAA, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_position_request() {
+  uint8_t data = 0x1;
+  return this->encode_(CMD_GET_POSITION, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_send_pin_request(uint16_t pin) {
+  uint8_t data[2];
+  data[0] = (pin & 0xFF00) >> 8;
+  data[1] = pin & 0xFF;
+  return this->encode_(CMD_SEND_PIN, data, 2);
+}
+
+Am43Packet *Am43Encoder::get_open_request() {
+  uint8_t data = 0xDD;
+  return this->encode_(CMD_SET_STATE, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_close_request() {
+  uint8_t data = 0xEE;
+  return this->encode_(CMD_SET_STATE, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_stop_request() {
+  uint8_t data = 0xCC;
+  return this->encode_(CMD_SET_STATE, &data, 1);
+}
+
+Am43Packet *Am43Encoder::get_set_position_request(uint8_t position) {
+  return this->encode_(CMD_SET_POSITION, &position, 1);
+}
+
+void Am43Encoder::checksum_() {
+  uint8_t checksum = 0;
+  int i = 0;
+  for (i = 0; i < this->packet_.length; i++)
+    checksum = checksum ^ this->packet_.data[i];
+  this->packet_.data[i] = checksum ^ 0xff;
+  this->packet_.length++;
+}
+
+Am43Packet *Am43Encoder::encode_(uint8_t command, uint8_t *data, uint8_t length) {
+  memcpy(this->packet_.data, START_PACKET, 5);
+  this->packet_.data[5] = command;
+  this->packet_.data[6] = length;
+  memcpy(&this->packet_.data[7], data, length);
+  this->packet_.length = length + 7;
+  this->checksum_();
+  ESP_LOGV("am43", "ENC(%d): 0x%s", packet_.length, pkt_to_hex(packet_.data, packet_.length).c_str());
+  return &this->packet_;
+}
+
+#define VERIFY_MIN_LENGTH(x) \
+  if (length < (x)) \
+    return;
+
+void Am43Decoder::decode(const uint8_t *data, uint16_t length) {
+  this->has_battery_level_ = false;
+  this->has_light_level_ = false;
+  this->has_set_position_response_ = false;
+  this->has_set_state_response_ = false;
+  this->has_position_ = false;
+  this->has_pin_response_ = false;
+  ESP_LOGV("am43", "DEC(%d): 0x%s", length, pkt_to_hex(data, length).c_str());
+
+  if (length < 2 || data[0] != 0x9a)
+    return;
+  switch (data[1]) {
+    case CMD_GET_BATTERY_LEVEL: {
+      VERIFY_MIN_LENGTH(8);
+      this->battery_level_ = data[7];
+      this->has_battery_level_ = true;
+      break;
+    }
+    case CMD_GET_LIGHT_LEVEL: {
+      VERIFY_MIN_LENGTH(5);
+      this->light_level_ = 100 * ((float) data[4] / 9);
+      this->has_light_level_ = true;
+      break;
+    }
+    case CMD_GET_POSITION: {
+      VERIFY_MIN_LENGTH(6);
+      this->position_ = data[5];
+      this->has_position_ = true;
+      break;
+    }
+    case CMD_NOTIFY_POSITION: {
+      VERIFY_MIN_LENGTH(5);
+      this->position_ = data[4];
+      this->has_position_ = true;
+      break;
+    }
+    case CMD_SEND_PIN: {
+      VERIFY_MIN_LENGTH(4);
+      this->pin_ok_ = data[3] == RESPONSE_ACK;
+      this->has_pin_response_ = true;
+      break;
+    }
+    case CMD_SET_POSITION: {
+      VERIFY_MIN_LENGTH(4);
+      this->set_position_ok_ = data[3] == RESPONSE_ACK;
+      this->has_set_position_response_ = true;
+      break;
+    }
+    case CMD_SET_STATE: {
+      VERIFY_MIN_LENGTH(4);
+      this->set_state_ok_ = data[3] == RESPONSE_ACK;
+      this->has_set_state_response_ = true;
+      break;
+    }
+    default:
+      break;
+  }
+};
+
+}  // namespace am43
+}  // namespace esphome

esphome/components/am43/am43_base.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace am43 {
+
+static const uint16_t AM43_SERVICE_UUID = 0xFE50;
+static const uint16_t AM43_CHARACTERISTIC_UUID = 0xFE51;
+//
+// Tuya identifiers, only to detect and warn users as they are incompatible.
+static const uint16_t AM43_TUYA_SERVICE_UUID = 0x1910;
+static const uint16_t AM43_TUYA_CHARACTERISTIC_UUID = 0x2b11;
+
+struct Am43Packet {
+  uint8_t length;
+  uint8_t data[24];
+};
+
+static const uint8_t CMD_GET_BATTERY_LEVEL = 0xA2;
+static const uint8_t CMD_GET_LIGHT_LEVEL = 0xAA;
+static const uint8_t CMD_GET_POSITION = 0xA7;
+static const uint8_t CMD_SEND_PIN = 0x17;
+static const uint8_t CMD_SET_STATE = 0x0A;
+static const uint8_t CMD_SET_POSITION = 0x0D;
+static const uint8_t CMD_NOTIFY_POSITION = 0xA1;
+
+static const uint8_t RESPONSE_ACK = 0x5A;
+static const uint8_t RESPONSE_NACK = 0xA5;
+
+class Am43Encoder {
+ public:
+  Am43Packet *get_battery_level_request();
+  Am43Packet *get_light_level_request();
+  Am43Packet *get_position_request();
+  Am43Packet *get_send_pin_request(uint16_t pin);
+  Am43Packet *get_open_request();
+  Am43Packet *get_close_request();
+  Am43Packet *get_stop_request();
+  Am43Packet *get_set_position_request(uint8_t position);
+
+ protected:
+  void checksum_();
+  Am43Packet *encode_(uint8_t command, uint8_t *data, uint8_t length);
+  Am43Packet packet_;
+};
+
+class Am43Decoder {
+ public:
+  void decode(const uint8_t *data, uint16_t length);
+  bool has_battery_level() { return this->has_battery_level_; }
+  bool has_light_level() { return this->has_light_level_; }
+  bool has_set_position_response() { return this->has_set_position_response_; }
+  bool has_set_state_response() { return this->has_set_state_response_; }
+  bool has_position() { return this->has_position_; }
+  bool has_pin_response() { return this->has_pin_response_; }
+
+  union {
+    uint8_t position_;
+    uint8_t battery_level_;
+    float light_level_;
+    uint8_t set_position_ok_;
+    uint8_t set_state_ok_;
+    uint8_t pin_ok_;
+  };
+
+ protected:
+  bool has_battery_level_;
+  bool has_light_level_;
+  bool has_set_position_response_;
+  bool has_set_state_response_;
+  bool has_position_;
+  bool has_pin_response_;
+};
+
+}  // namespace am43
+}  // namespace esphome

esphome/components/am43/cover/__init__.py

@@ -0,0 +1,36 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import cover, ble_client
+from esphome.const import CONF_ID, CONF_PIN
+
+CODEOWNERS = ["@buxtronix"]
+DEPENDENCIES = ["ble_client"]
+AUTO_LOAD = ["am43"]
+
+CONF_INVERT_POSITION = "invert_position"
+
+am43_ns = cg.esphome_ns.namespace("am43")
+Am43Component = am43_ns.class_(
+    "Am43Component", cover.Cover, ble_client.BLEClientNode, cg.Component
+)
+
+CONFIG_SCHEMA = (
+    cover.COVER_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(Am43Component),
+            cv.Optional(CONF_PIN, default=8888): cv.int_range(min=0, max=0xFFFF),
+            cv.Optional(CONF_INVERT_POSITION, default=False): cv.boolean,
+        }
+    )
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    cg.add(var.set_pin(config[CONF_PIN]))
+    cg.add(var.set_invert_position(config[CONF_INVERT_POSITION]))
+    yield cg.register_component(var, config)
+    yield cover.register_cover(var, config)
+    yield ble_client.register_ble_node(var, config)

esphome/components/am43/cover/am43_cover.cpp

@@ -0,0 +1,149 @@
+#include "am43_cover.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace am43 {
+
+static const char *TAG = "am43_cover";
+
+using namespace esphome::cover;
+
+void Am43Component::dump_config() {
+  LOG_COVER("", "AM43 Cover", this);
+  ESP_LOGCONFIG(TAG, "  Device Pin: %d", this->pin_);
+  ESP_LOGCONFIG(TAG, "  Invert Position: %d", (int) this->invert_position_);
+}
+
+void Am43Component::setup() {
+  this->position = COVER_OPEN;
+  this->encoder_ = new Am43Encoder();
+  this->decoder_ = new Am43Decoder();
+  this->logged_in_ = false;
+}
+
+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_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);
+    else
+      this->logged_in_ = true;
+  }
+}
+
+CoverTraits Am43Component::get_traits() {
+  auto traits = CoverTraits();
+  traits.set_supports_position(true);
+  traits.set_supports_tilt(false);
+  traits.set_is_assumed_state(false);
+  return traits;
+}
+
+void Am43Component::control(const CoverCall &call) {
+  if (this->node_state != espbt::ClientState::Established) {
+    ESP_LOGW(TAG, "[%s] Cannot send cover control, not connected", this->get_name().c_str());
+    return;
+  }
+  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_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();
+
+    if (this->invert_position_)
+      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_LOGW(TAG, "[%s] Error writing set_position command to device, error = %d", this->get_name().c_str(), status);
+  }
+}
+
+void Am43Component::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_DISCONNECT_EVT: {
+      this->logged_in_ = false;
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      auto chr = this->parent_->get_characteristic(AM43_SERVICE_UUID, AM43_CHARACTERISTIC_UUID);
+      if (chr == nullptr) {
+        if (this->parent_->get_characteristic(AM43_TUYA_SERVICE_UUID, AM43_TUYA_CHARACTERISTIC_UUID) != nullptr) {
+          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.", this->get_name().c_str());
+        } else {
+          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?", this->get_name().c_str());
+        }
+        break;
+      }
+      this->char_handle_ = chr->handle;
+
+      auto status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->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);
+      }
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      this->node_state = espbt::ClientState::Established;
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.handle != this->char_handle_)
+        break;
+      this->decoder_->decode(param->notify.value, param->notify.value_len);
+
+      if (this->decoder_->has_position()) {
+        this->position = ((float) this->decoder_->position_ / 100.0);
+        if (!this->invert_position_)
+          this->position = 1 - this->position;
+        if (this->position > 0.97)
+          this->position = 1.0;
+        if (this->position < 0.02)
+          this->position = 0.0;
+        this->publish_state();
+      }
+
+      if (this->decoder_->has_pin_response()) {
+        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)
+            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_)
+        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_)
+        ESP_LOGW(TAG, "[%s] Got nack after sending set_state. Bad pin?", this->get_name().c_str());
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+}  // namespace am43
+}  // namespace esphome
+
+#endif

esphome/components/am43/cover/am43_cover.h

@@ -0,0 +1,45 @@
+#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/cover/cover.h"
+#include "esphome/components/am43/am43_base.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace am43 {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class Am43Component : public cover::Cover, public esphome::ble_client::BLEClientNode, public Component {
+ public:
+  void setup() override;
+  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;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  cover::CoverTraits get_traits() override;
+  void set_pin(uint16_t pin) { this->pin_ = pin; }
+  void set_invert_position(bool invert_position) { this->invert_position_ = invert_position; }
+
+ protected:
+  void control(const cover::CoverCall &call) override;
+  uint16_t char_handle_;
+  uint16_t pin_;
+  bool invert_position_;
+  Am43Encoder *encoder_;
+  Am43Decoder *decoder_;
+  bool logged_in_;
+
+  float position_;
+};
+
+}  // namespace am43
+}  // namespace esphome
+
+#endif

esphome/components/am43/sensor.py

@@ -0,0 +1,46 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, ble_client
+from esphome.const import (
+    CONF_ID,
+    CONF_BATTERY_LEVEL,
+    ICON_BATTERY,
+    CONF_ILLUMINANCE,
+    ICON_BRIGHTNESS_5,
+    UNIT_PERCENT,
+)
+
+CODEOWNERS = ["@buxtronix"]
+
+am43_ns = cg.esphome_ns.namespace("am43")
+Am43 = am43_ns.class_("Am43", ble_client.BLEClientNode, cg.PollingComponent)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(Am43),
+            cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+                UNIT_PERCENT, ICON_BATTERY, 0
+            ),
+            cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(
+                UNIT_PERCENT, ICON_BRIGHTNESS_5, 0
+            ),
+        }
+    )
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+    .extend(cv.polling_component_schema("120s"))
+)
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    yield cg.register_component(var, config)
+    yield ble_client.register_ble_node(var, config)
+
+    if CONF_BATTERY_LEVEL in config:
+        sens = yield sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery(sens))
+
+    if CONF_ILLUMINANCE in config:
+        sens = yield sensor.new_sensor(config[CONF_ILLUMINANCE])
+        cg.add(var.set_illuminance(sens))

esphome/components/animation/__init__.py

@@ -0,0 +1,106 @@
+import logging
+
+from esphome import core
+from esphome.components import display, font
+import esphome.components.image as espImage
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_FILE, CONF_ID, CONF_TYPE, CONF_RESIZE
+from esphome.core import CORE, HexInt
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ["display"]
+MULTI_CONF = True
+
+Animation_ = display.display_ns.class_("Animation")
+
+CONF_RAW_DATA_ID = "raw_data_id"
+
+ANIMATION_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(Animation_),
+        cv.Required(CONF_FILE): cv.file_,
+        cv.Optional(CONF_RESIZE): cv.dimensions,
+        cv.Optional(CONF_TYPE, default="BINARY"): cv.enum(
+            espImage.IMAGE_TYPE, upper=True
+        ),
+        cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
+    }
+)
+
+CONFIG_SCHEMA = cv.All(font.validate_pillow_installed, ANIMATION_SCHEMA)
+
+CODEOWNERS = ["@syndlex"]
+
+
+async def to_code(config):
+    from PIL import Image
+
+    path = CORE.relative_config_path(config[CONF_FILE])
+    try:
+        image = Image.open(path)
+    except Exception as e:
+        raise core.EsphomeError(f"Could not load image file {path}: {e}")
+
+    width, height = image.size
+    frames = image.n_frames
+    if CONF_RESIZE in config:
+        image.thumbnail(config[CONF_RESIZE])
+        width, height = image.size
+    else:
+        if width > 500 or height > 500:
+            _LOGGER.warning(
+                "The image you requested is very big. Please consider using"
+                " the resize parameter."
+            )
+
+    if config[CONF_TYPE] == "GRAYSCALE":
+        data = [0 for _ in range(height * width * frames)]
+        pos = 0
+        for frameIndex in range(frames):
+            image.seek(frameIndex)
+            frame = image.convert("L", dither=Image.NONE)
+            pixels = list(frame.getdata())
+            for pix in pixels:
+                data[pos] = pix
+                pos += 1
+
+    elif config[CONF_TYPE] == "RGB24":
+        data = [0 for _ in range(height * width * 3 * frames)]
+        pos = 0
+        for frameIndex in range(frames):
+            image.seek(frameIndex)
+            frame = image.convert("RGB")
+            pixels = list(frame.getdata())
+            for pix in pixels:
+                data[pos] = pix[0]
+                pos += 1
+                data[pos] = pix[1]
+                pos += 1
+                data[pos] = pix[2]
+                pos += 1
+
+    elif config[CONF_TYPE] == "BINARY":
+        width8 = ((width + 7) // 8) * 8
+        data = [0 for _ in range((height * width8 // 8) * frames)]
+        for frameIndex in range(frames):
+            image.seek(frameIndex)
+            frame = image.convert("1", dither=Image.NONE)
+            for y in range(height):
+                for x in range(width):
+                    if frame.getpixel((x, y)):
+                        continue
+                    pos = x + y * width8 + (height * width8 * frameIndex)
+                    data[pos // 8] |= 0x80 >> (pos % 8)
+
+    rhs = [HexInt(x) for x in data]
+    prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
+    cg.new_Pvariable(
+        config[CONF_ID],
+        prog_arr,
+        width,
+        height,
+        frames,
+        espImage.IMAGE_TYPE[config[CONF_TYPE]],
+    )

esphome/components/anova/anova.cpp

@@ -0,0 +1,150 @@
+#include "anova.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace anova {
+
+static const char *TAG = "anova";
+
+using namespace esphome::climate;
+
+void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
+
+void Anova::setup() {
+  this->codec_ = new AnovaCodec();
+  this->current_request_ = 0;
+}
+
+void Anova::loop() {}
+
+void Anova::control(const ClimateCall &call) {
+  if (call.get_mode().has_value()) {
+    ClimateMode mode = *call.get_mode();
+    AnovaPacket *pkt;
+    switch (mode) {
+      case climate::CLIMATE_MODE_OFF:
+        pkt = this->codec_->get_stop_request();
+        break;
+      case climate::CLIMATE_MODE_HEAT:
+        pkt = this->codec_->get_start_request();
+        break;
+      default:
+        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)
+      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)
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+  }
+}
+
+void Anova::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_DISCONNECT_EVT: {
+      this->current_temperature = NAN;
+      this->target_temperature = NAN;
+      this->publish_state();
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      auto chr = this->parent_->get_characteristic(ANOVA_SERVICE_UUID, ANOVA_CHARACTERISTIC_UUID);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "[%s] No control service found at device, not an Anova..?", this->get_name().c_str());
+        ESP_LOGW(TAG, "[%s] Note, this component does not currently support Anova Nano.", this->get_name().c_str());
+        break;
+      }
+      this->char_handle_ = chr->handle;
+
+      auto status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->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);
+      }
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      this->node_state = espbt::ClientState::Established;
+      this->current_request_ = 0;
+      this->update();
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.handle != this->char_handle_)
+        break;
+      this->codec_->decode(param->notify.value, param->notify.value_len);
+      if (this->codec_->has_target_temp()) {
+        this->target_temperature = this->codec_->target_temp_;
+      }
+      if (this->codec_->has_current_temp()) {
+        this->current_temperature = this->codec_->current_temp_;
+      }
+      if (this->codec_->has_running()) {
+        this->mode = this->codec_->running_ ? climate::CLIMATE_MODE_HEAT : climate::CLIMATE_MODE_OFF;
+      }
+      if (this->codec_->has_unit()) {
+        this->fahrenheit_ = (this->codec_->unit_ == 'f');
+        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celcius");
+        this->current_request_++;
+      }
+      this->publish_state();
+
+      if (this->current_request_ > 1) {
+        AnovaPacket *pkt = nullptr;
+        switch (this->current_request_++) {
+          case 2:
+            pkt = this->codec_->get_read_target_temp_request();
+            break;
+          case 3:
+            pkt = this->codec_->get_read_current_temp_request();
+            break;
+          default:
+            this->current_request_ = 1;
+            break;
+        }
+        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);
+          if (status)
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
+                     status);
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void Anova::set_unit_of_measurement(const char *unit) { this->fahrenheit_ = !strncmp(unit, "f", 1); }
+
+void Anova::update() {
+  if (this->node_state != espbt::ClientState::Established)
+    return;
+
+  if (this->current_request_ < 2) {
+    auto pkt = this->codec_->get_read_device_status_request();
+    if (this->current_request_ == 0)
+      auto pkt = 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)
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    this->current_request_++;
+  }
+}
+
+}  // namespace anova
+}  // namespace esphome
+
+#endif

esphome/components/anova/anova.h

@@ -0,0 +1,52 @@
+#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/climate/climate.h"
+#include "anova_base.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace anova {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+static const uint16_t ANOVA_SERVICE_UUID = 0xFFE0;
+static const uint16_t ANOVA_CHARACTERISTIC_UUID = 0xFFE1;
+
+class Anova : public climate::Climate, public esphome::ble_client::BLEClientNode, public PollingComponent {
+ public:
+  void setup() override;
+  void loop() override;
+  void update() 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;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  climate::ClimateTraits traits() {
+    auto traits = climate::ClimateTraits();
+    traits.set_supports_current_temperature(true);
+    traits.set_supports_heat_mode(true);
+    traits.set_visual_min_temperature(25.0);
+    traits.set_visual_max_temperature(100.0);
+    traits.set_visual_temperature_step(0.1);
+    return traits;
+  }
+  void set_unit_of_measurement(const char *);
+
+ protected:
+  AnovaCodec *codec_;
+  void control(const climate::ClimateCall &call) override;
+  uint16_t char_handle_;
+  uint8_t current_request_;
+  bool fahrenheit_;
+};
+
+}  // namespace anova
+}  // namespace esphome
+
+#endif

esphome/components/anova/anova_base.cpp

@@ -0,0 +1,137 @@
+#include "anova_base.h"
+
+namespace esphome {
+namespace anova {
+
+float ftoc(float f) { return (f - 32.0) * (5.0f / 9.0f); }
+
+float ctof(float c) { return (c * 9.0f / 5.0f) + 32.0; }
+
+AnovaPacket *AnovaCodec::clean_packet_() {
+  this->packet_.length = strlen((char *) this->packet_.data);
+  this->packet_.data[this->packet_.length] = '\0';
+  ESP_LOGV("anova", "SendPkt: %s\n", this->packet_.data);
+  return &this->packet_;
+}
+
+AnovaPacket *AnovaCodec::get_read_device_status_request() {
+  this->current_query_ = READ_DEVICE_STATUS;
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_DEVICE_STATUS);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_read_target_temp_request() {
+  this->current_query_ = READ_TARGET_TEMPERATURE;
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_TARGET_TEMP);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_read_current_temp_request() {
+  this->current_query_ = READ_CURRENT_TEMPERATURE;
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_CURRENT_TEMP);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_read_unit_request() {
+  this->current_query_ = READ_UNIT;
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_UNIT);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_read_data_request() {
+  this->current_query_ = READ_DATA;
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_DATA);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_set_target_temp_request(float temperature) {
+  this->current_query_ = SET_TARGET_TEMPERATURE;
+  if (this->fahrenheit_)
+    temperature = ctof(temperature);
+  sprintf((char *) this->packet_.data, CMD_SET_TARGET_TEMP, temperature);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_set_unit_request(char unit) {
+  this->current_query_ = SET_UNIT;
+  sprintf((char *) this->packet_.data, CMD_SET_TEMP_UNIT, unit);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_start_request() {
+  this->current_query_ = START;
+  sprintf((char *) this->packet_.data, CMD_START);
+  return this->clean_packet_();
+}
+
+AnovaPacket *AnovaCodec::get_stop_request() {
+  this->current_query_ = STOP;
+  sprintf((char *) this->packet_.data, CMD_STOP);
+  return this->clean_packet_();
+}
+
+void AnovaCodec::decode(const uint8_t *data, uint16_t length) {
+  memset(this->buf_, 0, 32);
+  strncpy(this->buf_, (char *) data, length);
+  this->has_target_temp_ = this->has_current_temp_ = this->has_unit_ = this->has_running_ = false;
+  switch (this->current_query_) {
+    case READ_DEVICE_STATUS: {
+      if (!strncmp(this->buf_, "stopped", 7)) {
+        this->has_running_ = true;
+        this->running_ = false;
+      }
+      if (!strncmp(this->buf_, "running", 7)) {
+        this->has_running_ = true;
+        this->running_ = true;
+      }
+      break;
+    }
+    case START: {
+      if (!strncmp(this->buf_, "start", 5)) {
+        this->has_running_ = true;
+        this->running_ = true;
+      }
+      break;
+    }
+    case STOP: {
+      if (!strncmp(this->buf_, "stop", 4)) {
+        this->has_running_ = true;
+        this->running_ = false;
+      }
+      break;
+    }
+    case READ_TARGET_TEMPERATURE: {
+      this->target_temp_ = strtof(this->buf_, nullptr);
+      if (this->fahrenheit_)
+        this->target_temp_ = ftoc(this->target_temp_);
+      this->has_target_temp_ = true;
+      break;
+    }
+    case SET_TARGET_TEMPERATURE: {
+      this->target_temp_ = strtof(this->buf_, nullptr);
+      if (this->fahrenheit_)
+        this->target_temp_ = ftoc(this->target_temp_);
+      this->has_target_temp_ = true;
+      break;
+    }
+    case READ_CURRENT_TEMPERATURE: {
+      this->current_temp_ = strtof(this->buf_, nullptr);
+      if (this->fahrenheit_)
+        this->current_temp_ = ftoc(this->current_temp_);
+      this->has_current_temp_ = true;
+      break;
+    }
+    case SET_UNIT:
+    case READ_UNIT: {
+      this->unit_ = this->buf_[0];
+      this->fahrenheit_ = this->buf_[0] == 'f';
+      this->has_unit_ = true;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+}  // namespace anova
+}  // namespace esphome

esphome/components/anova/anova_base.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace anova {
+
+enum CurrentQuery {
+  NONE,
+  READ_DEVICE_STATUS,
+  READ_TARGET_TEMPERATURE,
+  READ_CURRENT_TEMPERATURE,
+  READ_DATA,
+  READ_UNIT,
+  SET_TARGET_TEMPERATURE,
+  SET_UNIT,
+  START,
+  STOP,
+};
+
+struct AnovaPacket {
+  uint16_t length;
+  uint8_t data[24];
+};
+
+#define CMD_READ_DEVICE_STATUS "status\r"
+#define CMD_READ_TARGET_TEMP "read set temp\r"
+#define CMD_READ_CURRENT_TEMP "read temp\r"
+#define CMD_READ_UNIT "read unit\r"
+#define CMD_READ_DATA "read data\r"
+#define CMD_SET_TARGET_TEMP "set temp %.1f\r"
+#define CMD_SET_TEMP_UNIT "set unit %c\r"
+
+#define CMD_START "start\r"
+#define CMD_STOP "stop\r"
+
+class AnovaCodec {
+ public:
+  AnovaPacket *get_read_device_status_request();
+  AnovaPacket *get_read_target_temp_request();
+  AnovaPacket *get_read_current_temp_request();
+  AnovaPacket *get_read_data_request();
+  AnovaPacket *get_read_unit_request();
+
+  AnovaPacket *get_set_target_temp_request(float temperature);
+  AnovaPacket *get_set_unit_request(char unit);
+
+  AnovaPacket *get_start_request();
+  AnovaPacket *get_stop_request();
+
+  void decode(const uint8_t *data, uint16_t length);
+  bool has_target_temp() { return this->has_target_temp_; }
+  bool has_current_temp() { return this->has_current_temp_; }
+  bool has_unit() { return this->has_unit_; }
+  bool has_running() { return this->has_running_; }
+
+  union {
+    float target_temp_;
+    float current_temp_;
+    char unit_;
+    bool running_;
+  };
+
+ protected:
+  AnovaPacket *clean_packet_();
+  AnovaPacket packet_;
+
+  bool has_target_temp_;
+  bool has_current_temp_;
+  bool has_unit_;
+  bool has_running_;
+  char buf_[32];
+  bool fahrenheit_;
+
+  CurrentQuery current_query_;
+};
+
+}  // namespace anova
+}  // namespace esphome

esphome/components/anova/climate.py

@@ -0,0 +1,36 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate, ble_client
+from esphome.const import CONF_ID, CONF_UNIT_OF_MEASUREMENT
+
+UNITS = {
+    "f": "f",
+    "c": "c",
+}
+
+CODEOWNERS = ["@buxtronix"]
+DEPENDENCIES = ["ble_client"]
+
+anova_ns = cg.esphome_ns.namespace("anova")
+Anova = anova_ns.class_(
+    "Anova", climate.Climate, ble_client.BLEClientNode, cg.PollingComponent
+)
+
+CONFIG_SCHEMA = (
+    climate.CLIMATE_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(Anova),
+            cv.Required(CONF_UNIT_OF_MEASUREMENT): cv.enum(UNITS),
+        }
+    )
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+    .extend(cv.polling_component_schema("60s"))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await climate.register_climate(var, config)
+    await ble_client.register_ble_node(var, config)
+    cg.add(var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))

esphome/components/apds9960/__init__.py

@@ -3,21 +3,27 @@ import esphome.config_validation as cv
 from esphome.components import i2c
 from esphome.const import CONF_ID
 
-DEPENDENCIES = ['i2c']
-AUTO_LOAD = ['sensor', 'binary_sensor']
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensor", "binary_sensor"]
 MULTI_CONF = True
 
-CONF_APDS9960_ID = 'apds9960_id'
+CONF_APDS9960_ID = "apds9960_id"
 
-apds9960_nds = cg.esphome_ns.namespace('apds9960')
-APDS9960 = apds9960_nds.class_('APDS9960', cg.PollingComponent, i2c.I2CDevice)
+apds9960_nds = cg.esphome_ns.namespace("apds9960")
+APDS9960 = apds9960_nds.class_("APDS9960", cg.PollingComponent, i2c.I2CDevice)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(APDS9960),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x39))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(APDS9960),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x39))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/apds9960/apds9960.cpp

@@ -4,10 +4,10 @@
 namespace esphome {
 namespace apds9960 {
 
-static const char *TAG = "apds9960";
+static const char *const TAG = "apds9960";
 
 #define APDS9960_ERROR_CHECK(func) \
-  if (!func) { \
+  if (!(func)) { \
     this->mark_failed(); \
     return; \
   }

esphome/components/apds9960/binary_sensor.py

@@ -4,24 +4,28 @@ from esphome.components import binary_sensor
 from esphome.const import CONF_DIRECTION, CONF_DEVICE_CLASS, DEVICE_CLASS_MOVING
 from . import APDS9960, CONF_APDS9960_ID
 
-DEPENDENCIES = ['apds9960']
+DEPENDENCIES = ["apds9960"]
 
 DIRECTIONS = {
-    'UP': 'set_up_direction',
-    'DOWN': 'set_down_direction',
-    'LEFT': 'set_left_direction',
-    'RIGHT': 'set_right_direction',
+    "UP": "set_up_direction",
+    "DOWN": "set_down_direction",
+    "LEFT": "set_left_direction",
+    "RIGHT": "set_right_direction",
 }
 
-CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
-    cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
-    cv.Optional(CONF_DEVICE_CLASS, default=DEVICE_CLASS_MOVING): binary_sensor.device_class,
-})
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+        cv.Optional(
+            CONF_DEVICE_CLASS, default=DEVICE_CLASS_MOVING
+        ): binary_sensor.device_class,
+    }
+)
 
 
-def to_code(config):
-    hub = yield cg.get_variable(config[CONF_APDS9960_ID])
-    var = yield binary_sensor.new_binary_sensor(config)
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_APDS9960_ID])
+    var = await binary_sensor.new_binary_sensor(config)
     func = getattr(hub, DIRECTIONS[config[CONF_DIRECTION]])
     cg.add(func(var))

esphome/components/apds9960/sensor.py

@@ -1,27 +1,39 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor
-from esphome.const import CONF_TYPE, UNIT_PERCENT, ICON_LIGHTBULB
+from esphome.const import (
+    CONF_TYPE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PERCENT,
+    ICON_LIGHTBULB,
+)
 from . import APDS9960, CONF_APDS9960_ID
 
-DEPENDENCIES = ['apds9960']
+DEPENDENCIES = ["apds9960"]
 
 TYPES = {
-    'CLEAR': 'set_clear_channel',
-    'RED': 'set_red_channel',
-    'GREEN': 'set_green_channel',
-    'BLUE': 'set_blue_channel',
-    'PROXIMITY': 'set_proximity',
+    "CLEAR": "set_clear_channel",
+    "RED": "set_red_channel",
+    "GREEN": "set_green_channel",
+    "BLUE": "set_blue_channel",
+    "PROXIMITY": "set_proximity",
 }
 
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_PERCENT, ICON_LIGHTBULB, 1).extend({
-    cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
-    cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
-})
+CONFIG_SCHEMA = sensor.sensor_schema(
+    unit_of_measurement=UNIT_PERCENT,
+    icon=ICON_LIGHTBULB,
+    accuracy_decimals=1,
+    state_class=STATE_CLASS_MEASUREMENT,
+).extend(
+    {
+        cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+    }
+)
 
 
-def to_code(config):
-    hub = yield cg.get_variable(config[CONF_APDS9960_ID])
-    var = yield sensor.new_sensor(config)
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_APDS9960_ID])
+    var = await sensor.new_sensor(config)
     func = getattr(hub, TYPES[config[CONF_TYPE]])
     cg.add(func(var))

esphome/components/api/__init__.py

@@ -2,52 +2,75 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 from esphome.automation import Condition
-from esphome.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
-    CONF_REBOOT_TIMEOUT, CONF_SERVICE, CONF_VARIABLES, CONF_SERVICES, CONF_TRIGGER_ID, CONF_EVENT, \
-    CONF_TAG
+from esphome.const import (
+    CONF_DATA,
+    CONF_DATA_TEMPLATE,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_REBOOT_TIMEOUT,
+    CONF_SERVICE,
+    CONF_VARIABLES,
+    CONF_SERVICES,
+    CONF_TRIGGER_ID,
+    CONF_EVENT,
+    CONF_TAG,
+)
 from esphome.core import coroutine_with_priority
 
-DEPENDENCIES = ['network']
-AUTO_LOAD = ['async_tcp']
-CODEOWNERS = ['@OttoWinter']
+DEPENDENCIES = ["network"]
+AUTO_LOAD = ["async_tcp"]
+CODEOWNERS = ["@OttoWinter"]
 
-api_ns = cg.esphome_ns.namespace('api')
-APIServer = api_ns.class_('APIServer', cg.Component, cg.Controller)
-HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', automation.Action)
-APIConnectedCondition = api_ns.class_('APIConnectedCondition', Condition)
+api_ns = cg.esphome_ns.namespace("api")
+APIServer = api_ns.class_("APIServer", cg.Component, cg.Controller)
+HomeAssistantServiceCallAction = api_ns.class_(
+    "HomeAssistantServiceCallAction", automation.Action
+)
+APIConnectedCondition = api_ns.class_("APIConnectedCondition", Condition)
 
-UserServiceTrigger = api_ns.class_('UserServiceTrigger', automation.Trigger)
-ListEntitiesServicesArgument = api_ns.class_('ListEntitiesServicesArgument')
+UserServiceTrigger = api_ns.class_("UserServiceTrigger", automation.Trigger)
+ListEntitiesServicesArgument = api_ns.class_("ListEntitiesServicesArgument")
 SERVICE_ARG_NATIVE_TYPES = {
-    'bool': bool,
-    'int': cg.int32,
-    'float': float,
-    'string': cg.std_string,
-    'bool[]': cg.std_vector.template(bool),
-    'int[]': cg.std_vector.template(cg.int32),
-    'float[]': cg.std_vector.template(float),
-    'string[]': cg.std_vector.template(cg.std_string),
+    "bool": bool,
+    "int": cg.int32,
+    "float": float,
+    "string": cg.std_string,
+    "bool[]": cg.std_vector.template(bool),
+    "int[]": cg.std_vector.template(cg.int32),
+    "float[]": cg.std_vector.template(float),
+    "string[]": cg.std_vector.template(cg.std_string),
 }
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(APIServer),
-    cv.Optional(CONF_PORT, default=6053): cv.port,
-    cv.Optional(CONF_PASSWORD, default=''): cv.string_strict,
-    cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_SERVICES): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger),
-        cv.Required(CONF_SERVICE): cv.valid_name,
-        cv.Optional(CONF_VARIABLES, default={}): cv.Schema({
-            cv.validate_id_name: cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
-        }),
-    }),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(APIServer),
+        cv.Optional(CONF_PORT, default=6053): cv.port,
+        cv.Optional(CONF_PASSWORD, default=""): cv.string_strict,
+        cv.Optional(
+            CONF_REBOOT_TIMEOUT, default="15min"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_SERVICES): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger),
+                cv.Required(CONF_SERVICE): cv.valid_name,
+                cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+                    {
+                        cv.validate_id_name: cv.one_of(
+                            *SERVICE_ARG_NATIVE_TYPES, lower=True
+                        ),
+                    }
+                ),
+            }
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
 @coroutine_with_priority(40.0)
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
+    await cg.register_component(var, config)
 
     cg.add(var.set_port(config[CONF_PORT]))
     cg.add(var.set_password(config[CONF_PASSWORD]))
@@ -63,98 +86,119 @@ def to_code(config):
             func_args.append((native, name))
             service_arg_names.append(name)
         templ = cg.TemplateArguments(*template_args)
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], templ,
-                                   conf[CONF_SERVICE], service_arg_names)
+        trigger = cg.new_Pvariable(
+            conf[CONF_TRIGGER_ID], templ, conf[CONF_SERVICE], service_arg_names
+        )
         cg.add(var.register_user_service(trigger))
-        yield automation.build_automation(trigger, func_args, conf)
+        await automation.build_automation(trigger, func_args, conf)
 
-    cg.add_define('USE_API')
+    cg.add_define("USE_API")
     cg.add_global(api_ns.using)
 
 
 KEY_VALUE_SCHEMA = cv.Schema({cv.string: cv.templatable(cv.string_strict)})
 
-HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_SERVICE): cv.templatable(cv.string),
-    cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_VARIABLES, default={}): cv.Schema({cv.string: cv.returning_lambda}),
-})
+HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_SERVICE): cv.templatable(cv.string),
+        cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+            {cv.string: cv.returning_lambda}
+        ),
+    }
+)
 
 
-@automation.register_action('homeassistant.service', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_SERVICE_ACTION_SCHEMA)
-def homeassistant_service_to_code(config, action_id, template_arg, args):
-    serv = yield cg.get_variable(config[CONF_ID])
+@automation.register_action(
+    "homeassistant.service",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_SERVICE_ACTION_SCHEMA,
+)
+async def homeassistant_service_to_code(config, action_id, template_arg, args):
+    serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, False)
-    templ = yield cg.templatable(config[CONF_SERVICE], args, None)
+    templ = await cg.templatable(config[CONF_SERVICE], args, None)
     cg.add(var.set_service(templ))
     for key, value in config[CONF_DATA].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_data(key, templ))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_data_template(key, templ))
     for key, value in config[CONF_VARIABLES].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_variable(key, templ))
-    yield var
+    return var
 
 
 def validate_homeassistant_event(value):
     value = cv.string(value)
-    if not value.startswith('esphome.'):
-        raise cv.Invalid("ESPHome can only generate Home Assistant events that begin with "
-                         "esphome. For example 'esphome.xyz'")
+    if not value.startswith("esphome."):
+        raise cv.Invalid(
+            "ESPHome can only generate Home Assistant events that begin with "
+            "esphome. For example 'esphome.xyz'"
+        )
     return value
 
 
-HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_EVENT): validate_homeassistant_event,
-    cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-    cv.Optional(CONF_VARIABLES, default={}): KEY_VALUE_SCHEMA,
-})
+HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_EVENT): validate_homeassistant_event,
+        cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
+        cv.Optional(CONF_VARIABLES, default={}): KEY_VALUE_SCHEMA,
+    }
+)
 
 
-@automation.register_action('homeassistant.event', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_EVENT_ACTION_SCHEMA)
-def homeassistant_event_to_code(config, action_id, template_arg, args):
-    serv = yield cg.get_variable(config[CONF_ID])
+@automation.register_action(
+    "homeassistant.event",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_EVENT_ACTION_SCHEMA,
+)
+async def homeassistant_event_to_code(config, action_id, template_arg, args):
+    serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    templ = yield cg.templatable(config[CONF_EVENT], args, None)
+    templ = await cg.templatable(config[CONF_EVENT], args, None)
     cg.add(var.set_service(templ))
     for key, value in config[CONF_DATA].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_data(key, templ))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_data_template(key, templ))
     for key, value in config[CONF_VARIABLES].items():
-        templ = yield cg.templatable(value, args, None)
+        templ = await cg.templatable(value, args, None)
         cg.add(var.add_variable(key, templ))
-    yield var
+    return var
 
 
-HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
-}, key=CONF_TAG)
+HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
+    },
+    key=CONF_TAG,
+)
 
 
-@automation.register_action('homeassistant.tag_scanned', HomeAssistantServiceCallAction,
-                            HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA)
-def homeassistant_tag_scanned_to_code(config, action_id, template_arg, args):
-    serv = yield cg.get_variable(config[CONF_ID])
+@automation.register_action(
+    "homeassistant.tag_scanned",
+    HomeAssistantServiceCallAction,
+    HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA,
+)
+async def homeassistant_tag_scanned_to_code(config, action_id, template_arg, args):
+    serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    cg.add(var.set_service('esphome.tag_scanned'))
-    templ = yield cg.templatable(config[CONF_TAG], args, cg.std_string)
-    cg.add(var.add_data('tag_id', templ))
-    yield var
+    cg.add(var.set_service("esphome.tag_scanned"))
+    templ = await cg.templatable(config[CONF_TAG], args, cg.std_string)
+    cg.add(var.add_data("tag_id", templ))
+    return var
 
 
-@automation.register_condition('api.connected', APIConnectedCondition, {})
-def api_connected_to_code(config, condition_id, template_arg, args):
-    yield cg.new_Pvariable(condition_id, template_arg)
+@automation.register_condition("api.connected", APIConnectedCondition, {})
+async def api_connected_to_code(config, condition_id, template_arg, args):
+    return cg.new_Pvariable(condition_id, template_arg)

esphome/components/api/api.proto

@@ -38,6 +38,8 @@ service APIConnection {
   rpc switch_command (SwitchCommandRequest) returns (void) {}
   rpc camera_image (CameraImageRequest) returns (void) {}
   rpc climate_command (ClimateCommandRequest) returns (void) {}
+  rpc number_command (NumberCommandRequest) returns (void) {}
+  rpc select_command (SelectCommandRequest) returns (void) {}
 }
 
 
@@ -46,6 +48,7 @@ service APIConnection {
 // The Home Assistant protocol is structured as a simple
 // TCP socket with short binary messages encoded in the protocol buffers format
 // First, a message in this protocol has a specific format:
+//  * A zero byte.
 //  * VarInt denoting the size of the message object. (type is not part of this)
 //  * VarInt denoting the type of message.
 //  * The message object encoded as a ProtoBuf message
@@ -175,6 +178,10 @@ message DeviceInfoResponse {
   string model = 6;
 
   bool has_deep_sleep = 7;
+
+  // The esphome project details if set
+  string project_name = 8;
+  string project_version = 9;
 }
 
 message ListEntitiesRequest {
@@ -207,6 +214,7 @@ message ListEntitiesBinarySensorResponse {
 
   string device_class = 5;
   bool is_status_binary_sensor = 6;
+  bool disabled_by_default = 7;
 }
 message BinarySensorStateResponse {
   option (id) = 21;
@@ -236,6 +244,7 @@ message ListEntitiesCoverResponse {
   bool supports_position = 6;
   bool supports_tilt = 7;
   string device_class = 8;
+  bool disabled_by_default = 9;
 }
 
 enum LegacyCoverState {
@@ -302,6 +311,8 @@ message ListEntitiesFanResponse {
   bool supports_oscillation = 5;
   bool supports_speed = 6;
   bool supports_direction = 7;
+  int32 supported_speed_count = 8;
+  bool disabled_by_default = 9;
 }
 enum FanSpeed {
   FAN_SPEED_LOW = 0;
@@ -321,8 +332,9 @@ message FanStateResponse {
   fixed32 key = 1;
   bool state = 2;
   bool oscillating = 3;
-  FanSpeed speed = 4;
+  FanSpeed speed = 4 [deprecated = true];
   FanDirection direction = 5;
+  int32 speed_level = 6;
 }
 message FanCommandRequest {
   option (id) = 31;
@@ -333,15 +345,29 @@ message FanCommandRequest {
   fixed32 key = 1;
   bool has_state = 2;
   bool state = 3;
-  bool has_speed = 4;
-  FanSpeed speed = 5;
+  bool has_speed = 4 [deprecated = true];
+  FanSpeed speed = 5 [deprecated = true];
   bool has_oscillating = 6;
   bool oscillating = 7;
   bool has_direction = 8;
   FanDirection direction = 9;
+  bool has_speed_level = 10;
+  int32 speed_level = 11;
 }
 
 // ==================== LIGHT ====================
+enum ColorMode {
+  COLOR_MODE_UNKNOWN = 0;
+  COLOR_MODE_ON_OFF = 1;
+  COLOR_MODE_BRIGHTNESS = 2;
+  COLOR_MODE_WHITE = 7;
+  COLOR_MODE_COLOR_TEMPERATURE = 11;
+  COLOR_MODE_COLD_WARM_WHITE = 19;
+  COLOR_MODE_RGB = 35;
+  COLOR_MODE_RGB_WHITE = 39;
+  COLOR_MODE_RGB_COLOR_TEMPERATURE = 47;
+  COLOR_MODE_RGB_COLD_WARM_WHITE = 51;
+}
 message ListEntitiesLightResponse {
   option (id) = 15;
   option (source) = SOURCE_SERVER;
@@ -352,13 +378,16 @@ message ListEntitiesLightResponse {
   string name = 3;
   string unique_id = 4;
 
-  bool supports_brightness = 5;
-  bool supports_rgb = 6;
-  bool supports_white_value = 7;
-  bool supports_color_temperature = 8;
+  repeated ColorMode supported_color_modes = 12;
+  // next four supports_* are for legacy clients, newer clients should use color modes
+  bool legacy_supports_brightness = 5 [deprecated=true];
+  bool legacy_supports_rgb = 6 [deprecated=true];
+  bool legacy_supports_white_value = 7 [deprecated=true];
+  bool legacy_supports_color_temperature = 8 [deprecated=true];
   float min_mireds = 9;
   float max_mireds = 10;
   repeated string effects = 11;
+  bool disabled_by_default = 13;
 }
 message LightStateResponse {
   option (id) = 24;
@@ -369,11 +398,15 @@ message LightStateResponse {
   fixed32 key = 1;
   bool state = 2;
   float brightness = 3;
+  ColorMode color_mode = 11;
+  float color_brightness = 10;
   float red = 4;
   float green = 5;
   float blue = 6;
   float white = 7;
   float color_temperature = 8;
+  float cold_white = 12;
+  float warm_white = 13;
   string effect = 9;
 }
 message LightCommandRequest {
@@ -387,6 +420,10 @@ message LightCommandRequest {
   bool state = 3;
   bool has_brightness = 4;
   float brightness = 5;
+  bool has_color_mode = 22;
+  ColorMode color_mode = 23;
+  bool has_color_brightness = 20;
+  float color_brightness = 21;
   bool has_rgb = 6;
   float red = 7;
   float green = 8;
@@ -395,6 +432,10 @@ message LightCommandRequest {
   float white = 11;
   bool has_color_temperature = 12;
   float color_temperature = 13;
+  bool has_cold_white = 24;
+  float cold_white = 25;
+  bool has_warm_white = 26;
+  float warm_white = 27;
   bool has_transition_length = 14;
   uint32 transition_length = 15;
   bool has_flash_length = 16;
@@ -404,6 +445,17 @@ message LightCommandRequest {
 }
 
 // ==================== SENSOR ====================
+enum SensorStateClass {
+  STATE_CLASS_NONE = 0;
+  STATE_CLASS_MEASUREMENT = 1;
+}
+
+enum SensorLastResetType {
+  LAST_RESET_NONE = 0;
+  LAST_RESET_NEVER = 1;
+  LAST_RESET_AUTO = 2;
+}
+
 message ListEntitiesSensorResponse {
   option (id) = 16;
   option (source) = SOURCE_SERVER;
@@ -418,6 +470,10 @@ message ListEntitiesSensorResponse {
   string unit_of_measurement = 6;
   int32 accuracy_decimals = 7;
   bool force_update = 8;
+  string device_class = 9;
+  SensorStateClass state_class = 10;
+  SensorLastResetType last_reset_type = 11;
+  bool disabled_by_default = 12;
 }
 message SensorStateResponse {
   option (id) = 25;
@@ -445,6 +501,7 @@ message ListEntitiesSwitchResponse {
 
   string icon = 5;
   bool assumed_state = 6;
+  bool disabled_by_default = 7;
 }
 message SwitchStateResponse {
   option (id) = 26;
@@ -477,6 +534,7 @@ message ListEntitiesTextSensorResponse {
   string unique_id = 4;
 
   string icon = 5;
+  bool disabled_by_default = 6;
 }
 message TextSensorStateResponse {
   option (id) = 27;
@@ -497,9 +555,10 @@ enum LogLevel {
   LOG_LEVEL_ERROR = 1;
   LOG_LEVEL_WARN = 2;
   LOG_LEVEL_INFO = 3;
-  LOG_LEVEL_DEBUG = 4;
-  LOG_LEVEL_VERBOSE = 5;
-  LOG_LEVEL_VERY_VERBOSE = 6;
+  LOG_LEVEL_CONFIG = 4;
+  LOG_LEVEL_DEBUG = 5;
+  LOG_LEVEL_VERBOSE = 6;
+  LOG_LEVEL_VERY_VERBOSE = 7;
 }
 message SubscribeLogsRequest {
   option (id) = 28;
@@ -514,7 +573,6 @@ message SubscribeLogsResponse {
   option (no_delay) = false;
 
   LogLevel level = 1;
-  string tag = 2;
   string message = 3;
   bool send_failed = 4;
 }
@@ -555,6 +613,7 @@ message SubscribeHomeAssistantStateResponse {
   option (id) = 39;
   option (source) = SOURCE_SERVER;
   string entity_id = 1;
+  string attribute = 2;
 }
 
 message HomeAssistantStateResponse {
@@ -564,6 +623,7 @@ message HomeAssistantStateResponse {
 
   string entity_id = 1;
   string state = 2;
+  string attribute = 3;
 }
 
 // ==================== IMPORT TIME ====================
@@ -634,6 +694,7 @@ message ListEntitiesCameraResponse {
   fixed32 key = 2;
   string name = 3;
   string unique_id = 4;
+  bool disabled_by_default = 5;
 }
 
 message CameraImageResponse {
@@ -658,11 +719,12 @@ message CameraImageRequest {
 // ==================== CLIMATE ====================
 enum ClimateMode {
   CLIMATE_MODE_OFF = 0;
-  CLIMATE_MODE_AUTO = 1;
+  CLIMATE_MODE_HEAT_COOL = 1;
   CLIMATE_MODE_COOL = 2;
   CLIMATE_MODE_HEAT = 3;
   CLIMATE_MODE_FAN_ONLY = 4;
   CLIMATE_MODE_DRY = 5;
+  CLIMATE_MODE_AUTO = 6;
 }
 enum ClimateFanMode {
   CLIMATE_FAN_ON = 0;
@@ -679,7 +741,7 @@ enum ClimateSwingMode {
   CLIMATE_SWING_OFF = 0;
   CLIMATE_SWING_BOTH = 1;
   CLIMATE_SWING_VERTICAL = 2;
-  CLIMATE_SWINT_HORIZONTAL = 3;
+  CLIMATE_SWING_HORIZONTAL = 3;
 }
 enum ClimateAction {
   CLIMATE_ACTION_OFF = 0;
@@ -690,6 +752,16 @@ enum ClimateAction {
   CLIMATE_ACTION_DRYING = 5;
   CLIMATE_ACTION_FAN = 6;
 }
+enum ClimatePreset {
+  CLIMATE_PRESET_NONE = 0;
+  CLIMATE_PRESET_HOME = 1;
+  CLIMATE_PRESET_AWAY = 2;
+  CLIMATE_PRESET_BOOST = 3;
+  CLIMATE_PRESET_COMFORT = 4;
+  CLIMATE_PRESET_ECO = 5;
+  CLIMATE_PRESET_SLEEP = 6;
+  CLIMATE_PRESET_ACTIVITY = 7;
+}
 message ListEntitiesClimateResponse {
   option (id) = 46;
   option (source) = SOURCE_SERVER;
@@ -706,10 +778,16 @@ message ListEntitiesClimateResponse {
   float visual_min_temperature = 8;
   float visual_max_temperature = 9;
   float visual_temperature_step = 10;
-  bool supports_away = 11;
+  // for older peer versions - in new system this
+  // is if CLIMATE_PRESET_AWAY exists is supported_presets
+  bool legacy_supports_away = 11;
   bool supports_action = 12;
   repeated ClimateFanMode supported_fan_modes = 13;
   repeated ClimateSwingMode supported_swing_modes = 14;
+  repeated string supported_custom_fan_modes = 15;
+  repeated ClimatePreset supported_presets = 16;
+  repeated string supported_custom_presets = 17;
+  bool disabled_by_default = 18;
 }
 message ClimateStateResponse {
   option (id) = 47;
@@ -723,10 +801,14 @@ message ClimateStateResponse {
   float target_temperature = 4;
   float target_temperature_low = 5;
   float target_temperature_high = 6;
-  bool away = 7;
+  // For older peers, equal to preset == CLIMATE_PRESET_AWAY
+  bool legacy_away = 7;
   ClimateAction action = 8;
   ClimateFanMode fan_mode = 9;
   ClimateSwingMode swing_mode = 10;
+  string custom_fan_mode = 11;
+  ClimatePreset preset = 12;
+  string custom_preset = 13;
 }
 message ClimateCommandRequest {
   option (id) = 48;
@@ -743,10 +825,93 @@ message ClimateCommandRequest {
   float target_temperature_low = 7;
   bool has_target_temperature_high = 8;
   float target_temperature_high = 9;
-  bool has_away = 10;
-  bool away = 11;
+  // legacy, for older peers, newer ones should use CLIMATE_PRESET_AWAY in preset
+  bool has_legacy_away = 10;
+  bool legacy_away = 11;
   bool has_fan_mode = 12;
   ClimateFanMode fan_mode = 13;
   bool has_swing_mode = 14;
   ClimateSwingMode swing_mode = 15;
+  bool has_custom_fan_mode = 16;
+  string custom_fan_mode = 17;
+  bool has_preset = 18;
+  ClimatePreset preset = 19;
+  bool has_custom_preset = 20;
+  string custom_preset = 21;
+}
+
+// ==================== NUMBER ====================
+message ListEntitiesNumberResponse {
+  option (id) = 49;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_NUMBER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  float min_value = 6;
+  float max_value = 7;
+  float step = 8;
+  bool disabled_by_default = 9;
+}
+message NumberStateResponse {
+  option (id) = 50;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_NUMBER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float state = 2;
+  // If the number does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
+}
+message NumberCommandRequest {
+  option (id) = 51;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_NUMBER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float state = 2;
+}
+
+// ==================== SELECT ====================
+message ListEntitiesSelectResponse {
+  option (id) = 52;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SELECT";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  repeated string options = 6;
+  bool disabled_by_default = 7;
+}
+message SelectStateResponse {
+  option (id) = 53;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SELECT";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  string state = 2;
+  // If the select does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
+}
+message SelectCommandRequest {
+  option (id) = 54;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SELECT";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  string state = 2;
 }

esphome/components/api/api_connection.cpp

@@ -9,11 +9,14 @@
 #ifdef USE_HOMEASSISTANT_TIME
 #include "esphome/components/homeassistant/time/homeassistant_time.h"
 #endif
+#ifdef USE_FAN
+#include "esphome/components/fan/fan_helpers.h"
+#endif
 
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.connection";
+static const char *const TAG = "api.connection";
 
 APIConnection::APIConnection(AsyncClient *client, APIServer *parent)
     : client_(client), parent_(parent), initial_state_iterator_(parent, this), list_entities_iterator_(parent, this) {
@@ -173,6 +176,7 @@ bool APIConnection::send_binary_sensor_info(binary_sensor::BinarySensor *binary_
   msg.unique_id = get_default_unique_id("binary_sensor", binary_sensor);
   msg.device_class = binary_sensor->get_device_class();
   msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
+  msg.disabled_by_default = binary_sensor->is_disabled_by_default();
   return this->send_list_entities_binary_sensor_response(msg);
 }
 #endif
@@ -204,6 +208,7 @@ bool APIConnection::send_cover_info(cover::Cover *cover) {
   msg.supports_position = traits.get_supports_position();
   msg.supports_tilt = traits.get_supports_tilt();
   msg.device_class = cover->get_device_class();
+  msg.disabled_by_default = cover->is_disabled_by_default();
   return this->send_list_entities_cover_response(msg);
 }
 void APIConnection::cover_command(const CoverCommandRequest &msg) {
@@ -246,8 +251,10 @@ bool APIConnection::send_fan_state(fan::FanState *fan) {
   resp.state = fan->state;
   if (traits.supports_oscillation())
     resp.oscillating = fan->oscillating;
-  if (traits.supports_speed())
-    resp.speed = static_cast<enums::FanSpeed>(fan->speed);
+  if (traits.supports_speed()) {
+    resp.speed_level = fan->speed;
+    resp.speed = static_cast<enums::FanSpeed>(fan::speed_level_to_enum(fan->speed, traits.supported_speed_count()));
+  }
   if (traits.supports_direction())
     resp.direction = static_cast<enums::FanDirection>(fan->direction);
   return this->send_fan_state_response(resp);
@@ -262,6 +269,8 @@ bool APIConnection::send_fan_info(fan::FanState *fan) {
   msg.supports_oscillation = traits.supports_oscillation();
   msg.supports_speed = traits.supports_speed();
   msg.supports_direction = traits.supports_direction();
+  msg.supported_speed_count = traits.supported_speed_count();
+  msg.disabled_by_default = fan->is_disabled_by_default();
   return this->send_list_entities_fan_response(msg);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
@@ -269,13 +278,19 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (fan == nullptr)
     return;
 
+  auto traits = fan->get_traits();
+
   auto call = fan->make_call();
   if (msg.has_state)
     call.set_state(msg.state);
   if (msg.has_oscillating)
     call.set_oscillating(msg.oscillating);
-  if (msg.has_speed)
-    call.set_speed(static_cast<fan::FanSpeed>(msg.speed));
+  if (msg.has_speed_level) {
+    // Prefer level
+    call.set_speed(msg.speed_level);
+  } else if (msg.has_speed) {
+    call.set_speed(fan::speed_enum_to_level(static_cast<fan::FanSpeed>(msg.speed), traits.supported_speed_count()));
+  }
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   call.perform();
@@ -289,21 +304,21 @@ bool APIConnection::send_light_state(light::LightState *light) {
 
   auto traits = light->get_traits();
   auto values = light->remote_values;
+  auto color_mode = values.get_color_mode();
   LightStateResponse resp{};
 
   resp.key = light->get_object_id_hash();
   resp.state = values.is_on();
-  if (traits.get_supports_brightness())
-    resp.brightness = values.get_brightness();
-  if (traits.get_supports_rgb()) {
-    resp.red = values.get_red();
-    resp.green = values.get_green();
-    resp.blue = values.get_blue();
-  }
-  if (traits.get_supports_rgb_white_value())
-    resp.white = values.get_white();
-  if (traits.get_supports_color_temperature())
-    resp.color_temperature = values.get_color_temperature();
+  resp.color_mode = static_cast<enums::ColorMode>(color_mode);
+  resp.brightness = values.get_brightness();
+  resp.color_brightness = values.get_color_brightness();
+  resp.red = values.get_red();
+  resp.green = values.get_green();
+  resp.blue = values.get_blue();
+  resp.white = values.get_white();
+  resp.color_temperature = values.get_color_temperature();
+  resp.cold_white = values.get_cold_white();
+  resp.warm_white = values.get_warm_white();
   if (light->supports_effects())
     resp.effect = light->get_effect_name();
   return this->send_light_state_response(resp);
@@ -315,11 +330,21 @@ bool APIConnection::send_light_info(light::LightState *light) {
   msg.object_id = light->get_object_id();
   msg.name = light->get_name();
   msg.unique_id = get_default_unique_id("light", light);
-  msg.supports_brightness = traits.get_supports_brightness();
-  msg.supports_rgb = traits.get_supports_rgb();
-  msg.supports_white_value = traits.get_supports_rgb_white_value();
-  msg.supports_color_temperature = traits.get_supports_color_temperature();
-  if (msg.supports_color_temperature) {
+
+  msg.disabled_by_default = light->is_disabled_by_default();
+
+  for (auto mode : traits.get_supported_color_modes())
+    msg.supported_color_modes.push_back(static_cast<enums::ColorMode>(mode));
+
+  msg.legacy_supports_brightness = traits.supports_color_capability(light::ColorCapability::BRIGHTNESS);
+  msg.legacy_supports_rgb = traits.supports_color_capability(light::ColorCapability::RGB);
+  msg.legacy_supports_white_value =
+      msg.legacy_supports_rgb && (traits.supports_color_capability(light::ColorCapability::WHITE) ||
+                                  traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE));
+  msg.legacy_supports_color_temperature = traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
+                                          traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE);
+
+  if (msg.legacy_supports_color_temperature) {
     msg.min_mireds = traits.get_min_mireds();
     msg.max_mireds = traits.get_max_mireds();
   }
@@ -340,6 +365,10 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
     call.set_state(msg.state);
   if (msg.has_brightness)
     call.set_brightness(msg.brightness);
+  if (msg.has_color_mode)
+    call.set_color_mode(static_cast<light::ColorMode>(msg.color_mode));
+  if (msg.has_color_brightness)
+    call.set_color_brightness(msg.color_brightness);
   if (msg.has_rgb) {
     call.set_red(msg.red);
     call.set_green(msg.green);
@@ -349,6 +378,10 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
     call.set_white(msg.white);
   if (msg.has_color_temperature)
     call.set_color_temperature(msg.color_temperature);
+  if (msg.has_cold_white)
+    call.set_cold_white(msg.cold_white);
+  if (msg.has_warm_white)
+    call.set_warm_white(msg.warm_white);
   if (msg.has_transition_length)
     call.set_transition_length(msg.transition_length);
   if (msg.has_flash_length)
@@ -382,6 +415,11 @@ bool APIConnection::send_sensor_info(sensor::Sensor *sensor) {
   msg.unit_of_measurement = sensor->get_unit_of_measurement();
   msg.accuracy_decimals = sensor->get_accuracy_decimals();
   msg.force_update = sensor->get_force_update();
+  msg.device_class = sensor->get_device_class();
+  msg.state_class = static_cast<enums::SensorStateClass>(sensor->state_class);
+  msg.last_reset_type = static_cast<enums::SensorLastResetType>(sensor->last_reset_type);
+  msg.disabled_by_default = sensor->is_disabled_by_default();
+
   return this->send_list_entities_sensor_response(msg);
 }
 #endif
@@ -404,6 +442,7 @@ bool APIConnection::send_switch_info(switch_::Switch *a_switch) {
   msg.unique_id = get_default_unique_id("switch", a_switch);
   msg.icon = a_switch->get_icon();
   msg.assumed_state = a_switch->assumed_state();
+  msg.disabled_by_default = a_switch->is_disabled_by_default();
   return this->send_list_entities_switch_response(msg);
 }
 void APIConnection::switch_command(const SwitchCommandRequest &msg) {
@@ -438,6 +477,7 @@ bool APIConnection::send_text_sensor_info(text_sensor::TextSensor *text_sensor)
   if (msg.unique_id.empty())
     msg.unique_id = get_default_unique_id("text_sensor", text_sensor);
   msg.icon = text_sensor->get_icon();
+  msg.disabled_by_default = text_sensor->is_disabled_by_default();
   return this->send_list_entities_text_sensor_response(msg);
 }
 #endif
@@ -460,10 +500,16 @@ bool APIConnection::send_climate_state(climate::Climate *climate) {
   } else {
     resp.target_temperature = climate->target_temperature;
   }
-  if (traits.get_supports_away())
-    resp.away = climate->away;
-  if (traits.get_supports_fan_modes())
-    resp.fan_mode = static_cast<enums::ClimateFanMode>(climate->fan_mode);
+  if (traits.get_supports_fan_modes() && climate->fan_mode.has_value())
+    resp.fan_mode = static_cast<enums::ClimateFanMode>(climate->fan_mode.value());
+  if (!traits.get_supported_custom_fan_modes().empty() && climate->custom_fan_mode.has_value())
+    resp.custom_fan_mode = climate->custom_fan_mode.value();
+  if (traits.get_supports_presets() && climate->preset.has_value()) {
+    resp.preset = static_cast<enums::ClimatePreset>(climate->preset.value());
+    resp.legacy_away = resp.preset == enums::CLIMATE_PRESET_AWAY;
+  }
+  if (!traits.get_supported_custom_presets().empty() && climate->custom_preset.has_value())
+    resp.custom_preset = climate->custom_preset.value();
   if (traits.get_supports_swing_modes())
     resp.swing_mode = static_cast<enums::ClimateSwingMode>(climate->swing_mode);
   return this->send_climate_state_response(resp);
@@ -475,29 +521,31 @@ bool APIConnection::send_climate_info(climate::Climate *climate) {
   msg.object_id = climate->get_object_id();
   msg.name = climate->get_name();
   msg.unique_id = get_default_unique_id("climate", climate);
+
+  msg.disabled_by_default = climate->is_disabled_by_default();
+
   msg.supports_current_temperature = traits.get_supports_current_temperature();
   msg.supports_two_point_target_temperature = traits.get_supports_two_point_target_temperature();
-  for (auto mode : {climate::CLIMATE_MODE_AUTO, climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL,
-                    climate::CLIMATE_MODE_HEAT, climate::CLIMATE_MODE_DRY, climate::CLIMATE_MODE_FAN_ONLY}) {
-    if (traits.supports_mode(mode))
-      msg.supported_modes.push_back(static_cast<enums::ClimateMode>(mode));
-  }
+
+  for (auto mode : traits.get_supported_modes())
+    msg.supported_modes.push_back(static_cast<enums::ClimateMode>(mode));
+
   msg.visual_min_temperature = traits.get_visual_min_temperature();
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_temperature_step = traits.get_visual_temperature_step();
-  msg.supports_away = traits.get_supports_away();
+  msg.legacy_supports_away = traits.supports_preset(climate::CLIMATE_PRESET_AWAY);
   msg.supports_action = traits.get_supports_action();
-  for (auto fan_mode : {climate::CLIMATE_FAN_ON, climate::CLIMATE_FAN_OFF, climate::CLIMATE_FAN_AUTO,
-                        climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
-                        climate::CLIMATE_FAN_MIDDLE, climate::CLIMATE_FAN_FOCUS, climate::CLIMATE_FAN_DIFFUSE}) {
-    if (traits.supports_fan_mode(fan_mode))
-      msg.supported_fan_modes.push_back(static_cast<enums::ClimateFanMode>(fan_mode));
-  }
-  for (auto swing_mode : {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH, climate::CLIMATE_SWING_VERTICAL,
-                          climate::CLIMATE_SWING_HORIZONTAL}) {
-    if (traits.supports_swing_mode(swing_mode))
-      msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
-  }
+
+  for (auto fan_mode : traits.get_supported_fan_modes())
+    msg.supported_fan_modes.push_back(static_cast<enums::ClimateFanMode>(fan_mode));
+  for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes())
+    msg.supported_custom_fan_modes.push_back(custom_fan_mode);
+  for (auto preset : traits.get_supported_presets())
+    msg.supported_presets.push_back(static_cast<enums::ClimatePreset>(preset));
+  for (auto const &custom_preset : traits.get_supported_custom_presets())
+    msg.supported_custom_presets.push_back(custom_preset);
+  for (auto swing_mode : traits.get_supported_swing_modes())
+    msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
   return this->send_list_entities_climate_response(msg);
 }
 void APIConnection::climate_command(const ClimateCommandRequest &msg) {
@@ -514,16 +562,95 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
     call.set_target_temperature_low(msg.target_temperature_low);
   if (msg.has_target_temperature_high)
     call.set_target_temperature_high(msg.target_temperature_high);
-  if (msg.has_away)
-    call.set_away(msg.away);
+  if (msg.has_legacy_away)
+    call.set_preset(msg.legacy_away ? climate::CLIMATE_PRESET_AWAY : climate::CLIMATE_PRESET_HOME);
   if (msg.has_fan_mode)
     call.set_fan_mode(static_cast<climate::ClimateFanMode>(msg.fan_mode));
+  if (msg.has_custom_fan_mode)
+    call.set_fan_mode(msg.custom_fan_mode);
+  if (msg.has_preset)
+    call.set_preset(static_cast<climate::ClimatePreset>(msg.preset));
+  if (msg.has_custom_preset)
+    call.set_preset(msg.custom_preset);
   if (msg.has_swing_mode)
     call.set_swing_mode(static_cast<climate::ClimateSwingMode>(msg.swing_mode));
   call.perform();
 }
 #endif
 
+#ifdef USE_NUMBER
+bool APIConnection::send_number_state(number::Number *number, float state) {
+  if (!this->state_subscription_)
+    return false;
+
+  NumberStateResponse resp{};
+  resp.key = number->get_object_id_hash();
+  resp.state = state;
+  resp.missing_state = !number->has_state();
+  return this->send_number_state_response(resp);
+}
+bool APIConnection::send_number_info(number::Number *number) {
+  ListEntitiesNumberResponse msg;
+  msg.key = number->get_object_id_hash();
+  msg.object_id = number->get_object_id();
+  msg.name = number->get_name();
+  msg.unique_id = get_default_unique_id("number", number);
+  msg.icon = number->traits.get_icon();
+  msg.disabled_by_default = number->is_disabled_by_default();
+
+  msg.min_value = number->traits.get_min_value();
+  msg.max_value = number->traits.get_max_value();
+  msg.step = number->traits.get_step();
+
+  return this->send_list_entities_number_response(msg);
+}
+void APIConnection::number_command(const NumberCommandRequest &msg) {
+  number::Number *number = App.get_number_by_key(msg.key);
+  if (number == nullptr)
+    return;
+
+  auto call = number->make_call();
+  call.set_value(msg.state);
+  call.perform();
+}
+#endif
+
+#ifdef USE_SELECT
+bool APIConnection::send_select_state(select::Select *select, std::string state) {
+  if (!this->state_subscription_)
+    return false;
+
+  SelectStateResponse resp{};
+  resp.key = select->get_object_id_hash();
+  resp.state = std::move(state);
+  resp.missing_state = !select->has_state();
+  return this->send_select_state_response(resp);
+}
+bool APIConnection::send_select_info(select::Select *select) {
+  ListEntitiesSelectResponse msg;
+  msg.key = select->get_object_id_hash();
+  msg.object_id = select->get_object_id();
+  msg.name = select->get_name();
+  msg.unique_id = get_default_unique_id("select", select);
+  msg.icon = select->traits.get_icon();
+  msg.disabled_by_default = select->is_disabled_by_default();
+
+  for (const auto &option : select->traits.get_options())
+    msg.options.push_back(option);
+
+  return this->send_list_entities_select_response(msg);
+}
+void APIConnection::select_command(const SelectCommandRequest &msg) {
+  select::Select *select = App.get_select_by_key(msg.key);
+  if (select == nullptr)
+    return;
+
+  auto call = select->make_call();
+  call.set_option(msg.state);
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)
@@ -538,6 +665,7 @@ bool APIConnection::send_camera_info(esp32_camera::ESP32Camera *camera) {
   msg.object_id = camera->get_object_id();
   msg.name = camera->get_name();
   msg.unique_id = get_default_unique_id("camera", camera);
+  msg.disabled_by_default = camera->is_disabled_by_default();
   return this->send_list_entities_camera_response(msg);
 }
 void APIConnection::camera_image(const CameraImageRequest &msg) {
@@ -566,8 +694,6 @@ bool APIConnection::send_log_message(int level, const char *tag, const char *lin
   auto buffer = this->create_buffer();
   // LogLevel level = 1;
   buffer.encode_uint32(1, static_cast<uint32_t>(level));
-  // string tag = 2;
-  // buffer.encode_string(2, tag, strlen(tag));
   // string message = 3;
   buffer.encode_string(3, line, strlen(line));
   // SubscribeLogsResponse - 29
@@ -589,7 +715,7 @@ HelloResponse APIConnection::hello(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 3;
+  resp.api_version_minor = 6;
   resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
   this->connection_state_ = ConnectionState::CONNECTED;
   return resp;
@@ -624,13 +750,18 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
 #endif
 #ifdef USE_DEEP_SLEEP
   resp.has_deep_sleep = deep_sleep::global_has_deep_sleep;
+#endif
+#ifdef ESPHOME_PROJECT_NAME
+  resp.project_name = ESPHOME_PROJECT_NAME;
+  resp.project_version = ESPHOME_PROJECT_VERSION;
 #endif
   return resp;
 }
 void APIConnection::on_home_assistant_state_response(const HomeAssistantStateResponse &msg) {
   for (auto &it : this->parent_->get_state_subs())
-    if (it.entity_id == msg.entity_id)
+    if (it.entity_id == msg.entity_id && it.attribute.value() == msg.attribute) {
       it.callback(msg.state);
+    }
 }
 void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   bool found = false;
@@ -647,6 +778,7 @@ void APIConnection::subscribe_home_assistant_states(const SubscribeHomeAssistant
   for (auto &it : this->parent_->get_state_subs()) {
     SubscribeHomeAssistantStateResponse resp;
     resp.entity_id = it.entity_id;
+    resp.attribute = it.attribute.value();
     if (!this->send_subscribe_home_assistant_state_response(resp)) {
       this->on_fatal_error();
       return;
@@ -676,8 +808,10 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint32_t message_type)
     }
   }
 
-  this->client_->add(reinterpret_cast<char *>(header.data()), header.size());
-  this->client_->add(reinterpret_cast<char *>(buffer.get_buffer()->data()), buffer.get_buffer()->size());
+  this->client_->add(reinterpret_cast<char *>(header.data()), header.size(),
+                     ASYNC_WRITE_FLAG_COPY | ASYNC_WRITE_FLAG_MORE);
+  this->client_->add(reinterpret_cast<char *>(buffer.get_buffer()->data()), buffer.get_buffer()->size(),
+                     ASYNC_WRITE_FLAG_COPY);
   bool ret = this->client_->send();
   return ret;
 }

esphome/components/api/api_connection.h

@@ -62,6 +62,16 @@ class APIConnection : public APIServerConnection {
   bool send_climate_state(climate::Climate *climate);
   bool send_climate_info(climate::Climate *climate);
   void climate_command(const ClimateCommandRequest &msg) override;
+#endif
+#ifdef USE_NUMBER
+  bool send_number_state(number::Number *number, float state);
+  bool send_number_info(number::Number *number);
+  void number_command(const NumberCommandRequest &msg) override;
+#endif
+#ifdef USE_SELECT
+  bool send_select_state(select::Select *select, std::string state);
+  bool send_select_info(select::Select *select);
+  void select_command(const SelectCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {

esphome/components/api/api_pb2.cpp

@@ -62,6 +62,54 @@ template<> const char *proto_enum_to_string<enums::FanDirection>(enums::FanDirec
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::ColorMode>(enums::ColorMode value) {
+  switch (value) {
+    case enums::COLOR_MODE_UNKNOWN:
+      return "COLOR_MODE_UNKNOWN";
+    case enums::COLOR_MODE_ON_OFF:
+      return "COLOR_MODE_ON_OFF";
+    case enums::COLOR_MODE_BRIGHTNESS:
+      return "COLOR_MODE_BRIGHTNESS";
+    case enums::COLOR_MODE_WHITE:
+      return "COLOR_MODE_WHITE";
+    case enums::COLOR_MODE_COLOR_TEMPERATURE:
+      return "COLOR_MODE_COLOR_TEMPERATURE";
+    case enums::COLOR_MODE_COLD_WARM_WHITE:
+      return "COLOR_MODE_COLD_WARM_WHITE";
+    case enums::COLOR_MODE_RGB:
+      return "COLOR_MODE_RGB";
+    case enums::COLOR_MODE_RGB_WHITE:
+      return "COLOR_MODE_RGB_WHITE";
+    case enums::COLOR_MODE_RGB_COLOR_TEMPERATURE:
+      return "COLOR_MODE_RGB_COLOR_TEMPERATURE";
+    case enums::COLOR_MODE_RGB_COLD_WARM_WHITE:
+      return "COLOR_MODE_RGB_COLD_WARM_WHITE";
+    default:
+      return "UNKNOWN";
+  }
+}
+template<> const char *proto_enum_to_string<enums::SensorStateClass>(enums::SensorStateClass value) {
+  switch (value) {
+    case enums::STATE_CLASS_NONE:
+      return "STATE_CLASS_NONE";
+    case enums::STATE_CLASS_MEASUREMENT:
+      return "STATE_CLASS_MEASUREMENT";
+    default:
+      return "UNKNOWN";
+  }
+}
+template<> const char *proto_enum_to_string<enums::SensorLastResetType>(enums::SensorLastResetType value) {
+  switch (value) {
+    case enums::LAST_RESET_NONE:
+      return "LAST_RESET_NONE";
+    case enums::LAST_RESET_NEVER:
+      return "LAST_RESET_NEVER";
+    case enums::LAST_RESET_AUTO:
+      return "LAST_RESET_AUTO";
+    default:
+      return "UNKNOWN";
+  }
+}
 template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel value) {
   switch (value) {
     case enums::LOG_LEVEL_NONE:
@@ -72,6 +120,8 @@ template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel val
       return "LOG_LEVEL_WARN";
     case enums::LOG_LEVEL_INFO:
       return "LOG_LEVEL_INFO";
+    case enums::LOG_LEVEL_CONFIG:
+      return "LOG_LEVEL_CONFIG";
     case enums::LOG_LEVEL_DEBUG:
       return "LOG_LEVEL_DEBUG";
     case enums::LOG_LEVEL_VERBOSE:
@@ -108,8 +158,8 @@ template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMo
   switch (value) {
     case enums::CLIMATE_MODE_OFF:
       return "CLIMATE_MODE_OFF";
-    case enums::CLIMATE_MODE_AUTO:
-      return "CLIMATE_MODE_AUTO";
+    case enums::CLIMATE_MODE_HEAT_COOL:
+      return "CLIMATE_MODE_HEAT_COOL";
     case enums::CLIMATE_MODE_COOL:
       return "CLIMATE_MODE_COOL";
     case enums::CLIMATE_MODE_HEAT:
@@ -118,6 +168,8 @@ template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMo
       return "CLIMATE_MODE_FAN_ONLY";
     case enums::CLIMATE_MODE_DRY:
       return "CLIMATE_MODE_DRY";
+    case enums::CLIMATE_MODE_AUTO:
+      return "CLIMATE_MODE_AUTO";
     default:
       return "UNKNOWN";
   }
@@ -154,8 +206,8 @@ template<> const char *proto_enum_to_string<enums::ClimateSwingMode>(enums::Clim
       return "CLIMATE_SWING_BOTH";
     case enums::CLIMATE_SWING_VERTICAL:
       return "CLIMATE_SWING_VERTICAL";
-    case enums::CLIMATE_SWINT_HORIZONTAL:
-      return "CLIMATE_SWINT_HORIZONTAL";
+    case enums::CLIMATE_SWING_HORIZONTAL:
+      return "CLIMATE_SWING_HORIZONTAL";
     default:
       return "UNKNOWN";
   }
@@ -178,6 +230,28 @@ template<> const char *proto_enum_to_string<enums::ClimateAction>(enums::Climate
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::ClimatePreset value) {
+  switch (value) {
+    case enums::CLIMATE_PRESET_NONE:
+      return "CLIMATE_PRESET_NONE";
+    case enums::CLIMATE_PRESET_HOME:
+      return "CLIMATE_PRESET_HOME";
+    case enums::CLIMATE_PRESET_AWAY:
+      return "CLIMATE_PRESET_AWAY";
+    case enums::CLIMATE_PRESET_BOOST:
+      return "CLIMATE_PRESET_BOOST";
+    case enums::CLIMATE_PRESET_COMFORT:
+      return "CLIMATE_PRESET_COMFORT";
+    case enums::CLIMATE_PRESET_ECO:
+      return "CLIMATE_PRESET_ECO";
+    case enums::CLIMATE_PRESET_SLEEP:
+      return "CLIMATE_PRESET_SLEEP";
+    case enums::CLIMATE_PRESET_ACTIVITY:
+      return "CLIMATE_PRESET_ACTIVITY";
+    default:
+      return "UNKNOWN";
+  }
+}
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -189,6 +263,7 @@ bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value)
   }
 }
 void HelloRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->client_info); }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("HelloRequest {\n");
@@ -197,6 +272,7 @@ void HelloRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool HelloResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -226,6 +302,7 @@ void HelloResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->api_version_minor);
   buffer.encode_string(3, this->server_info);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void HelloResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("HelloResponse {\n");
@@ -244,6 +321,7 @@ void HelloResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ConnectRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -255,6 +333,7 @@ bool ConnectRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value
   }
 }
 void ConnectRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->password); }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ConnectRequest {\n");
@@ -263,6 +342,7 @@ void ConnectRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ConnectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -274,6 +354,7 @@ bool ConnectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   }
 }
 void ConnectResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->invalid_password); }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ConnectResponse {\n");
@@ -282,16 +363,27 @@ void ConnectResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 void DisconnectRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void DisconnectRequest::dump_to(std::string &out) const { out.append("DisconnectRequest {}"); }
+#endif
 void DisconnectResponse::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void DisconnectResponse::dump_to(std::string &out) const { out.append("DisconnectResponse {}"); }
+#endif
 void PingRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void PingRequest::dump_to(std::string &out) const { out.append("PingRequest {}"); }
+#endif
 void PingResponse::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void PingResponse::dump_to(std::string &out) const { out.append("PingResponse {}"); }
+#endif
 void DeviceInfoRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoRequest::dump_to(std::string &out) const { out.append("DeviceInfoRequest {}"); }
+#endif
 bool DeviceInfoResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -328,6 +420,14 @@ bool DeviceInfoResponse::decode_length(uint32_t field_id, ProtoLengthDelimited v
       this->model = value.as_string();
       return true;
     }
+    case 8: {
+      this->project_name = value.as_string();
+      return true;
+    }
+    case 9: {
+      this->project_version = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -340,7 +440,10 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(5, this->compilation_time);
   buffer.encode_string(6, this->model);
   buffer.encode_bool(7, this->has_deep_sleep);
+  buffer.encode_string(8, this->project_name);
+  buffer.encode_string(9, this->project_version);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("DeviceInfoResponse {\n");
@@ -371,20 +474,39 @@ void DeviceInfoResponse::dump_to(std::string &out) const {
   out.append("  has_deep_sleep: ");
   out.append(YESNO(this->has_deep_sleep));
   out.append("\n");
+
+  out.append("  project_name: ");
+  out.append("'").append(this->project_name).append("'");
+  out.append("\n");
+
+  out.append("  project_version: ");
+  out.append("'").append(this->project_version).append("'");
+  out.append("\n");
   out.append("}");
 }
+#endif
 void ListEntitiesRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesRequest::dump_to(std::string &out) const { out.append("ListEntitiesRequest {}"); }
+#endif
 void ListEntitiesDoneResponse::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesDoneResponse::dump_to(std::string &out) const { out.append("ListEntitiesDoneResponse {}"); }
+#endif
 void SubscribeStatesRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeStatesRequest::dump_to(std::string &out) const { out.append("SubscribeStatesRequest {}"); }
+#endif
 bool ListEntitiesBinarySensorResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 6: {
       this->is_status_binary_sensor = value.as_bool();
       return true;
     }
+    case 7: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -428,7 +550,9 @@ void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->device_class);
   buffer.encode_bool(6, this->is_status_binary_sensor);
+  buffer.encode_bool(7, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesBinarySensorResponse {\n");
@@ -456,8 +580,13 @@ void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
   out.append("  is_status_binary_sensor: ");
   out.append(YESNO(this->is_status_binary_sensor));
   out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool BinarySensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -487,6 +616,7 @@ void BinarySensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void BinarySensorStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("BinarySensorStateResponse {\n");
@@ -504,6 +634,7 @@ void BinarySensorStateResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesCoverResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 5: {
@@ -518,6 +649,10 @@ bool ListEntitiesCoverResponse::decode_varint(uint32_t field_id, ProtoVarInt val
       this->supports_tilt = value.as_bool();
       return true;
     }
+    case 9: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -563,7 +698,9 @@ void ListEntitiesCoverResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(6, this->supports_position);
   buffer.encode_bool(7, this->supports_tilt);
   buffer.encode_string(8, this->device_class);
+  buffer.encode_bool(9, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCoverResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesCoverResponse {\n");
@@ -599,8 +736,13 @@ void ListEntitiesCoverResponse::dump_to(std::string &out) const {
   out.append("  device_class: ");
   out.append("'").append(this->device_class).append("'");
   out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool CoverStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -640,6 +782,7 @@ void CoverStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(4, this->tilt);
   buffer.encode_enum<enums::CoverOperation>(5, this->current_operation);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("CoverStateResponse {\n");
@@ -667,6 +810,7 @@ void CoverStateResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool CoverCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -721,6 +865,7 @@ void CoverCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(7, this->tilt);
   buffer.encode_bool(8, this->stop);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverCommandRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("CoverCommandRequest {\n");
@@ -760,6 +905,7 @@ void CoverCommandRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesFanResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 5: {
@@ -774,6 +920,14 @@ bool ListEntitiesFanResponse::decode_varint(uint32_t field_id, ProtoVarInt value
       this->supports_direction = value.as_bool();
       return true;
     }
+    case 8: {
+      this->supported_speed_count = value.as_int32();
+      return true;
+    }
+    case 9: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -814,7 +968,10 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(5, this->supports_oscillation);
   buffer.encode_bool(6, this->supports_speed);
   buffer.encode_bool(7, this->supports_direction);
+  buffer.encode_int32(8, this->supported_speed_count);
+  buffer.encode_bool(9, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesFanResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesFanResponse {\n");
@@ -846,8 +1003,18 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
   out.append("  supports_direction: ");
   out.append(YESNO(this->supports_direction));
   out.append("\n");
+
+  out.append("  supported_speed_count: ");
+  sprintf(buffer, "%d", this->supported_speed_count);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool FanStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -866,6 +1033,10 @@ bool FanStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->direction = value.as_enum<enums::FanDirection>();
       return true;
     }
+    case 6: {
+      this->speed_level = value.as_int32();
+      return true;
+    }
     default:
       return false;
   }
@@ -886,7 +1057,9 @@ void FanStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->oscillating);
   buffer.encode_enum<enums::FanSpeed>(4, this->speed);
   buffer.encode_enum<enums::FanDirection>(5, this->direction);
+  buffer.encode_int32(6, this->speed_level);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void FanStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("FanStateResponse {\n");
@@ -910,8 +1083,14 @@ void FanStateResponse::dump_to(std::string &out) const {
   out.append("  direction: ");
   out.append(proto_enum_to_string<enums::FanDirection>(this->direction));
   out.append("\n");
+
+  out.append("  speed_level: ");
+  sprintf(buffer, "%d", this->speed_level);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -946,6 +1125,14 @@ bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->direction = value.as_enum<enums::FanDirection>();
       return true;
     }
+    case 10: {
+      this->has_speed_level = value.as_bool();
+      return true;
+    }
+    case 11: {
+      this->speed_level = value.as_int32();
+      return true;
+    }
     default:
       return false;
   }
@@ -970,7 +1157,10 @@ void FanCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(7, this->oscillating);
   buffer.encode_bool(8, this->has_direction);
   buffer.encode_enum<enums::FanDirection>(9, this->direction);
+  buffer.encode_bool(10, this->has_speed_level);
+  buffer.encode_int32(11, this->speed_level);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void FanCommandRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("FanCommandRequest {\n");
@@ -1010,24 +1200,42 @@ void FanCommandRequest::dump_to(std::string &out) const {
   out.append("  direction: ");
   out.append(proto_enum_to_string<enums::FanDirection>(this->direction));
   out.append("\n");
+
+  out.append("  has_speed_level: ");
+  out.append(YESNO(this->has_speed_level));
+  out.append("\n");
+
+  out.append("  speed_level: ");
+  sprintf(buffer, "%d", this->speed_level);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesLightResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
+    case 12: {
+      this->supported_color_modes.push_back(value.as_enum<enums::ColorMode>());
+      return true;
+    }
     case 5: {
-      this->supports_brightness = value.as_bool();
+      this->legacy_supports_brightness = value.as_bool();
       return true;
     }
     case 6: {
-      this->supports_rgb = value.as_bool();
+      this->legacy_supports_rgb = value.as_bool();
       return true;
     }
     case 7: {
-      this->supports_white_value = value.as_bool();
+      this->legacy_supports_white_value = value.as_bool();
       return true;
     }
     case 8: {
-      this->supports_color_temperature = value.as_bool();
+      this->legacy_supports_color_temperature = value.as_bool();
+      return true;
+    }
+    case 13: {
+      this->disabled_by_default = value.as_bool();
       return true;
     }
     default:
@@ -1079,16 +1287,21 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
   buffer.encode_string(4, this->unique_id);
-  buffer.encode_bool(5, this->supports_brightness);
-  buffer.encode_bool(6, this->supports_rgb);
-  buffer.encode_bool(7, this->supports_white_value);
-  buffer.encode_bool(8, this->supports_color_temperature);
+  for (auto &it : this->supported_color_modes) {
+    buffer.encode_enum<enums::ColorMode>(12, it, true);
+  }
+  buffer.encode_bool(5, this->legacy_supports_brightness);
+  buffer.encode_bool(6, this->legacy_supports_rgb);
+  buffer.encode_bool(7, this->legacy_supports_white_value);
+  buffer.encode_bool(8, this->legacy_supports_color_temperature);
   buffer.encode_float(9, this->min_mireds);
   buffer.encode_float(10, this->max_mireds);
   for (auto &it : this->effects) {
     buffer.encode_string(11, it, true);
   }
+  buffer.encode_bool(13, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesLightResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesLightResponse {\n");
@@ -1109,20 +1322,26 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
   out.append("'").append(this->unique_id).append("'");
   out.append("\n");
 
-  out.append("  supports_brightness: ");
-  out.append(YESNO(this->supports_brightness));
+  for (const auto &it : this->supported_color_modes) {
+    out.append("  supported_color_modes: ");
+    out.append(proto_enum_to_string<enums::ColorMode>(it));
+    out.append("\n");
+  }
+
+  out.append("  legacy_supports_brightness: ");
+  out.append(YESNO(this->legacy_supports_brightness));
   out.append("\n");
 
-  out.append("  supports_rgb: ");
-  out.append(YESNO(this->supports_rgb));
+  out.append("  legacy_supports_rgb: ");
+  out.append(YESNO(this->legacy_supports_rgb));
   out.append("\n");
 
-  out.append("  supports_white_value: ");
-  out.append(YESNO(this->supports_white_value));
+  out.append("  legacy_supports_white_value: ");
+  out.append(YESNO(this->legacy_supports_white_value));
   out.append("\n");
 
-  out.append("  supports_color_temperature: ");
-  out.append(YESNO(this->supports_color_temperature));
+  out.append("  legacy_supports_color_temperature: ");
+  out.append(YESNO(this->legacy_supports_color_temperature));
   out.append("\n");
 
   out.append("  min_mireds: ");
@@ -1140,14 +1359,23 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
     out.append("'").append(it).append("'");
     out.append("\n");
   }
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool LightStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
       this->state = value.as_bool();
       return true;
     }
+    case 11: {
+      this->color_mode = value.as_enum<enums::ColorMode>();
+      return true;
+    }
     default:
       return false;
   }
@@ -1172,6 +1400,10 @@ bool LightStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->brightness = value.as_float();
       return true;
     }
+    case 10: {
+      this->color_brightness = value.as_float();
+      return true;
+    }
     case 4: {
       this->red = value.as_float();
       return true;
@@ -1192,6 +1424,14 @@ bool LightStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->color_temperature = value.as_float();
       return true;
     }
+    case 12: {
+      this->cold_white = value.as_float();
+      return true;
+    }
+    case 13: {
+      this->warm_white = value.as_float();
+      return true;
+    }
     default:
       return false;
   }
@@ -1200,13 +1440,18 @@ void LightStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
   buffer.encode_float(3, this->brightness);
+  buffer.encode_enum<enums::ColorMode>(11, this->color_mode);
+  buffer.encode_float(10, this->color_brightness);
   buffer.encode_float(4, this->red);
   buffer.encode_float(5, this->green);
   buffer.encode_float(6, this->blue);
   buffer.encode_float(7, this->white);
   buffer.encode_float(8, this->color_temperature);
+  buffer.encode_float(12, this->cold_white);
+  buffer.encode_float(13, this->warm_white);
   buffer.encode_string(9, this->effect);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void LightStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("LightStateResponse {\n");
@@ -1224,6 +1469,15 @@ void LightStateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  color_mode: ");
+  out.append(proto_enum_to_string<enums::ColorMode>(this->color_mode));
+  out.append("\n");
+
+  out.append("  color_brightness: ");
+  sprintf(buffer, "%g", this->color_brightness);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  red: ");
   sprintf(buffer, "%g", this->red);
   out.append(buffer);
@@ -1249,11 +1503,22 @@ void LightStateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  cold_white: ");
+  sprintf(buffer, "%g", this->cold_white);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  warm_white: ");
+  sprintf(buffer, "%g", this->warm_white);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  effect: ");
   out.append("'").append(this->effect).append("'");
   out.append("\n");
   out.append("}");
 }
+#endif
 bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -1268,6 +1533,18 @@ bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->has_brightness = value.as_bool();
       return true;
     }
+    case 22: {
+      this->has_color_mode = value.as_bool();
+      return true;
+    }
+    case 23: {
+      this->color_mode = value.as_enum<enums::ColorMode>();
+      return true;
+    }
+    case 20: {
+      this->has_color_brightness = value.as_bool();
+      return true;
+    }
     case 6: {
       this->has_rgb = value.as_bool();
       return true;
@@ -1280,6 +1557,14 @@ bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->has_color_temperature = value.as_bool();
       return true;
     }
+    case 24: {
+      this->has_cold_white = value.as_bool();
+      return true;
+    }
+    case 26: {
+      this->has_warm_white = value.as_bool();
+      return true;
+    }
     case 14: {
       this->has_transition_length = value.as_bool();
       return true;
@@ -1324,6 +1609,10 @@ bool LightCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->brightness = value.as_float();
       return true;
     }
+    case 21: {
+      this->color_brightness = value.as_float();
+      return true;
+    }
     case 7: {
       this->red = value.as_float();
       return true;
@@ -1344,6 +1633,14 @@ bool LightCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->color_temperature = value.as_float();
       return true;
     }
+    case 25: {
+      this->cold_white = value.as_float();
+      return true;
+    }
+    case 27: {
+      this->warm_white = value.as_float();
+      return true;
+    }
     default:
       return false;
   }
@@ -1354,6 +1651,10 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->state);
   buffer.encode_bool(4, this->has_brightness);
   buffer.encode_float(5, this->brightness);
+  buffer.encode_bool(22, this->has_color_mode);
+  buffer.encode_enum<enums::ColorMode>(23, this->color_mode);
+  buffer.encode_bool(20, this->has_color_brightness);
+  buffer.encode_float(21, this->color_brightness);
   buffer.encode_bool(6, this->has_rgb);
   buffer.encode_float(7, this->red);
   buffer.encode_float(8, this->green);
@@ -1362,6 +1663,10 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(11, this->white);
   buffer.encode_bool(12, this->has_color_temperature);
   buffer.encode_float(13, this->color_temperature);
+  buffer.encode_bool(24, this->has_cold_white);
+  buffer.encode_float(25, this->cold_white);
+  buffer.encode_bool(26, this->has_warm_white);
+  buffer.encode_float(27, this->warm_white);
   buffer.encode_bool(14, this->has_transition_length);
   buffer.encode_uint32(15, this->transition_length);
   buffer.encode_bool(16, this->has_flash_length);
@@ -1369,6 +1674,7 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(18, this->has_effect);
   buffer.encode_string(19, this->effect);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void LightCommandRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("LightCommandRequest {\n");
@@ -1394,6 +1700,23 @@ void LightCommandRequest::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  has_color_mode: ");
+  out.append(YESNO(this->has_color_mode));
+  out.append("\n");
+
+  out.append("  color_mode: ");
+  out.append(proto_enum_to_string<enums::ColorMode>(this->color_mode));
+  out.append("\n");
+
+  out.append("  has_color_brightness: ");
+  out.append(YESNO(this->has_color_brightness));
+  out.append("\n");
+
+  out.append("  color_brightness: ");
+  sprintf(buffer, "%g", this->color_brightness);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  has_rgb: ");
   out.append(YESNO(this->has_rgb));
   out.append("\n");
@@ -1431,6 +1754,24 @@ void LightCommandRequest::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  has_cold_white: ");
+  out.append(YESNO(this->has_cold_white));
+  out.append("\n");
+
+  out.append("  cold_white: ");
+  sprintf(buffer, "%g", this->cold_white);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_warm_white: ");
+  out.append(YESNO(this->has_warm_white));
+  out.append("\n");
+
+  out.append("  warm_white: ");
+  sprintf(buffer, "%g", this->warm_white);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  has_transition_length: ");
   out.append(YESNO(this->has_transition_length));
   out.append("\n");
@@ -1458,6 +1799,7 @@ void LightCommandRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesSensorResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 7: {
@@ -1468,6 +1810,18 @@ bool ListEntitiesSensorResponse::decode_varint(uint32_t field_id, ProtoVarInt va
       this->force_update = value.as_bool();
       return true;
     }
+    case 10: {
+      this->state_class = value.as_enum<enums::SensorStateClass>();
+      return true;
+    }
+    case 11: {
+      this->last_reset_type = value.as_enum<enums::SensorLastResetType>();
+      return true;
+    }
+    case 12: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -1494,6 +1848,10 @@ bool ListEntitiesSensorResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->unit_of_measurement = value.as_string();
       return true;
     }
+    case 9: {
+      this->device_class = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -1517,7 +1875,12 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(6, this->unit_of_measurement);
   buffer.encode_int32(7, this->accuracy_decimals);
   buffer.encode_bool(8, this->force_update);
+  buffer.encode_string(9, this->device_class);
+  buffer.encode_enum<enums::SensorStateClass>(10, this->state_class);
+  buffer.encode_enum<enums::SensorLastResetType>(11, this->last_reset_type);
+  buffer.encode_bool(12, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesSensorResponse {\n");
@@ -1554,8 +1917,25 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   out.append("  force_update: ");
   out.append(YESNO(this->force_update));
   out.append("\n");
+
+  out.append("  device_class: ");
+  out.append("'").append(this->device_class).append("'");
+  out.append("\n");
+
+  out.append("  state_class: ");
+  out.append(proto_enum_to_string<enums::SensorStateClass>(this->state_class));
+  out.append("\n");
+
+  out.append("  last_reset_type: ");
+  out.append(proto_enum_to_string<enums::SensorLastResetType>(this->last_reset_type));
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool SensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 3: {
@@ -1585,6 +1965,7 @@ void SensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SensorStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SensorStateResponse {\n");
@@ -1603,12 +1984,17 @@ void SensorStateResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesSwitchResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 6: {
       this->assumed_state = value.as_bool();
       return true;
     }
+    case 7: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -1652,7 +2038,9 @@ void ListEntitiesSwitchResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->assumed_state);
+  buffer.encode_bool(7, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesSwitchResponse {\n");
@@ -1680,8 +2068,13 @@ void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
   out.append("  assumed_state: ");
   out.append(YESNO(this->assumed_state));
   out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool SwitchStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -1706,6 +2099,7 @@ void SwitchStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SwitchStateResponse {\n");
@@ -1719,6 +2113,7 @@ void SwitchStateResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool SwitchCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -1743,6 +2138,7 @@ void SwitchCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchCommandRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SwitchCommandRequest {\n");
@@ -1756,6 +2152,17 @@ void SwitchCommandRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
+bool ListEntitiesTextSensorResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 bool ListEntitiesTextSensorResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -1794,7 +2201,9 @@ void ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(3, this->name);
   buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
+  buffer.encode_bool(6, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesTextSensorResponse {\n");
@@ -1818,8 +2227,13 @@ void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool TextSensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 3: {
@@ -1855,6 +2269,7 @@ void TextSensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->state);
   buffer.encode_bool(3, this->missing_state);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void TextSensorStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("TextSensorStateResponse {\n");
@@ -1872,6 +2287,7 @@ void TextSensorStateResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool SubscribeLogsRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -1890,6 +2306,7 @@ void SubscribeLogsRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::LogLevel>(1, this->level);
   buffer.encode_bool(2, this->dump_config);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SubscribeLogsRequest {\n");
@@ -1902,6 +2319,7 @@ void SubscribeLogsRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool SubscribeLogsResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -1918,10 +2336,6 @@ bool SubscribeLogsResponse::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool SubscribeLogsResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2: {
-      this->tag = value.as_string();
-      return true;
-    }
     case 3: {
       this->message = value.as_string();
       return true;
@@ -1932,10 +2346,10 @@ bool SubscribeLogsResponse::decode_length(uint32_t field_id, ProtoLengthDelimite
 }
 void SubscribeLogsResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::LogLevel>(1, this->level);
-  buffer.encode_string(2, this->tag);
   buffer.encode_string(3, this->message);
   buffer.encode_bool(4, this->send_failed);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SubscribeLogsResponse {\n");
@@ -1943,10 +2357,6 @@ void SubscribeLogsResponse::dump_to(std::string &out) const {
   out.append(proto_enum_to_string<enums::LogLevel>(this->level));
   out.append("\n");
 
-  out.append("  tag: ");
-  out.append("'").append(this->tag).append("'");
-  out.append("\n");
-
   out.append("  message: ");
   out.append("'").append(this->message).append("'");
   out.append("\n");
@@ -1956,10 +2366,13 @@ void SubscribeLogsResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 void SubscribeHomeassistantServicesRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeassistantServicesRequest::dump_to(std::string &out) const {
   out.append("SubscribeHomeassistantServicesRequest {}");
 }
+#endif
 bool HomeassistantServiceMap::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -1978,6 +2391,7 @@ void HomeassistantServiceMap::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->key);
   buffer.encode_string(2, this->value);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceMap::dump_to(std::string &out) const {
   char buffer[64];
   out.append("HomeassistantServiceMap {\n");
@@ -1990,6 +2404,7 @@ void HomeassistantServiceMap::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool HomeassistantServiceResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 5: {
@@ -2035,6 +2450,7 @@ void HomeassistantServiceResponse::encode(ProtoWriteBuffer buffer) const {
   }
   buffer.encode_bool(5, this->is_event);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeassistantServiceResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("HomeassistantServiceResponse {\n");
@@ -2065,31 +2481,45 @@ void HomeassistantServiceResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 void SubscribeHomeAssistantStatesRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStatesRequest::dump_to(std::string &out) const {
   out.append("SubscribeHomeAssistantStatesRequest {}");
 }
+#endif
 bool SubscribeHomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
       this->entity_id = value.as_string();
       return true;
     }
+    case 2: {
+      this->attribute = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
 }
 void SubscribeHomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->entity_id);
+  buffer.encode_string(2, this->attribute);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("SubscribeHomeAssistantStateResponse {\n");
   out.append("  entity_id: ");
   out.append("'").append(this->entity_id).append("'");
   out.append("\n");
+
+  out.append("  attribute: ");
+  out.append("'").append(this->attribute).append("'");
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -2100,6 +2530,10 @@ bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->state = value.as_string();
       return true;
     }
+    case 3: {
+      this->attribute = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -2107,7 +2541,9 @@ bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDel
 void HomeAssistantStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->entity_id);
   buffer.encode_string(2, this->state);
+  buffer.encode_string(3, this->attribute);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void HomeAssistantStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("HomeAssistantStateResponse {\n");
@@ -2118,10 +2554,17 @@ void HomeAssistantStateResponse::dump_to(std::string &out) const {
   out.append("  state: ");
   out.append("'").append(this->state).append("'");
   out.append("\n");
+
+  out.append("  attribute: ");
+  out.append("'").append(this->attribute).append("'");
+  out.append("\n");
   out.append("}");
 }
+#endif
 void GetTimeRequest::encode(ProtoWriteBuffer buffer) const {}
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeRequest::dump_to(std::string &out) const { out.append("GetTimeRequest {}"); }
+#endif
 bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   switch (field_id) {
     case 1: {
@@ -2133,6 +2576,7 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
   }
 }
 void GetTimeResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->epoch_seconds); }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("GetTimeResponse {\n");
@@ -2142,6 +2586,7 @@ void GetTimeResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesServicesArgument::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -2166,6 +2611,7 @@ void ListEntitiesServicesArgument::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->name);
   buffer.encode_enum<enums::ServiceArgType>(2, this->type);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesArgument::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesServicesArgument {\n");
@@ -2178,6 +2624,7 @@ void ListEntitiesServicesArgument::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesServicesResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -2209,6 +2656,7 @@ void ListEntitiesServicesResponse::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<ListEntitiesServicesArgument>(3, it, true);
   }
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesServicesResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesServicesResponse {\n");
@@ -2228,6 +2676,7 @@ void ListEntitiesServicesResponse::dump_to(std::string &out) const {
   }
   out.append("}");
 }
+#endif
 bool ExecuteServiceArgument::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -2301,6 +2750,7 @@ void ExecuteServiceArgument::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_string(9, it, true);
   }
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceArgument::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ExecuteServiceArgument {\n");
@@ -2354,6 +2804,7 @@ void ExecuteServiceArgument::dump_to(std::string &out) const {
   }
   out.append("}");
 }
+#endif
 bool ExecuteServiceRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
@@ -2380,6 +2831,7 @@ void ExecuteServiceRequest::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message<ExecuteServiceArgument>(2, it, true);
   }
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ExecuteServiceRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ExecuteServiceRequest {\n");
@@ -2395,6 +2847,17 @@ void ExecuteServiceRequest::dump_to(std::string &out) const {
   }
   out.append("}");
 }
+#endif
+bool ListEntitiesCameraResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 5: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 bool ListEntitiesCameraResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
@@ -2428,7 +2891,9 @@ void ListEntitiesCameraResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
   buffer.encode_string(4, this->unique_id);
+  buffer.encode_bool(5, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesCameraResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesCameraResponse {\n");
@@ -2448,8 +2913,13 @@ void ListEntitiesCameraResponse::dump_to(std::string &out) const {
   out.append("  unique_id: ");
   out.append("'").append(this->unique_id).append("'");
   out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool CameraImageResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 3: {
@@ -2485,6 +2955,7 @@ void CameraImageResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(2, this->data);
   buffer.encode_bool(3, this->done);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("CameraImageResponse {\n");
@@ -2502,6 +2973,7 @@ void CameraImageResponse::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool CameraImageRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 1: {
@@ -2520,6 +2992,7 @@ void CameraImageRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(1, this->single);
   buffer.encode_bool(2, this->stream);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("CameraImageRequest {\n");
@@ -2532,6 +3005,7 @@ void CameraImageRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+#endif
 bool ListEntitiesClimateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 5: {
@@ -2547,7 +3021,7 @@ bool ListEntitiesClimateResponse::decode_varint(uint32_t field_id, ProtoVarInt v
       return true;
     }
     case 11: {
-      this->supports_away = value.as_bool();
+      this->legacy_supports_away = value.as_bool();
       return true;
     }
     case 12: {
@@ -2562,6 +3036,14 @@ bool ListEntitiesClimateResponse::decode_varint(uint32_t field_id, ProtoVarInt v
       this->supported_swing_modes.push_back(value.as_enum<enums::ClimateSwingMode>());
       return true;
     }
+    case 16: {
+      this->supported_presets.push_back(value.as_enum<enums::ClimatePreset>());
+      return true;
+    }
+    case 18: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
     default:
       return false;
   }
@@ -2580,6 +3062,14 @@ bool ListEntitiesClimateResponse::decode_length(uint32_t field_id, ProtoLengthDe
       this->unique_id = value.as_string();
       return true;
     }
+    case 15: {
+      this->supported_custom_fan_modes.push_back(value.as_string());
+      return true;
+    }
+    case 17: {
+      this->supported_custom_presets.push_back(value.as_string());
+      return true;
+    }
     default:
       return false;
   }
@@ -2619,7 +3109,7 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(8, this->visual_min_temperature);
   buffer.encode_float(9, this->visual_max_temperature);
   buffer.encode_float(10, this->visual_temperature_step);
-  buffer.encode_bool(11, this->supports_away);
+  buffer.encode_bool(11, this->legacy_supports_away);
   buffer.encode_bool(12, this->supports_action);
   for (auto &it : this->supported_fan_modes) {
     buffer.encode_enum<enums::ClimateFanMode>(13, it, true);
@@ -2627,7 +3117,18 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   for (auto &it : this->supported_swing_modes) {
     buffer.encode_enum<enums::ClimateSwingMode>(14, it, true);
   }
+  for (auto &it : this->supported_custom_fan_modes) {
+    buffer.encode_string(15, it, true);
+  }
+  for (auto &it : this->supported_presets) {
+    buffer.encode_enum<enums::ClimatePreset>(16, it, true);
+  }
+  for (auto &it : this->supported_custom_presets) {
+    buffer.encode_string(17, it, true);
+  }
+  buffer.encode_bool(18, this->disabled_by_default);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ListEntitiesClimateResponse {\n");
@@ -2677,8 +3178,8 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  supports_away: ");
-  out.append(YESNO(this->supports_away));
+  out.append("  legacy_supports_away: ");
+  out.append(YESNO(this->legacy_supports_away));
   out.append("\n");
 
   out.append("  supports_action: ");
@@ -2696,8 +3197,31 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
     out.append(proto_enum_to_string<enums::ClimateSwingMode>(it));
     out.append("\n");
   }
+
+  for (const auto &it : this->supported_custom_fan_modes) {
+    out.append("  supported_custom_fan_modes: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
+
+  for (const auto &it : this->supported_presets) {
+    out.append("  supported_presets: ");
+    out.append(proto_enum_to_string<enums::ClimatePreset>(it));
+    out.append("\n");
+  }
+
+  for (const auto &it : this->supported_custom_presets) {
+    out.append("  supported_custom_presets: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool ClimateStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -2705,7 +3229,7 @@ bool ClimateStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       return true;
     }
     case 7: {
-      this->away = value.as_bool();
+      this->legacy_away = value.as_bool();
       return true;
     }
     case 8: {
@@ -2720,6 +3244,24 @@ bool ClimateStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->swing_mode = value.as_enum<enums::ClimateSwingMode>();
       return true;
     }
+    case 12: {
+      this->preset = value.as_enum<enums::ClimatePreset>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ClimateStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 11: {
+      this->custom_fan_mode = value.as_string();
+      return true;
+    }
+    case 13: {
+      this->custom_preset = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -2757,11 +3299,15 @@ void ClimateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(4, this->target_temperature);
   buffer.encode_float(5, this->target_temperature_low);
   buffer.encode_float(6, this->target_temperature_high);
-  buffer.encode_bool(7, this->away);
+  buffer.encode_bool(7, this->legacy_away);
   buffer.encode_enum<enums::ClimateAction>(8, this->action);
   buffer.encode_enum<enums::ClimateFanMode>(9, this->fan_mode);
   buffer.encode_enum<enums::ClimateSwingMode>(10, this->swing_mode);
+  buffer.encode_string(11, this->custom_fan_mode);
+  buffer.encode_enum<enums::ClimatePreset>(12, this->preset);
+  buffer.encode_string(13, this->custom_preset);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateStateResponse::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ClimateStateResponse {\n");
@@ -2794,8 +3340,8 @@ void ClimateStateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  away: ");
-  out.append(YESNO(this->away));
+  out.append("  legacy_away: ");
+  out.append(YESNO(this->legacy_away));
   out.append("\n");
 
   out.append("  action: ");
@@ -2809,8 +3355,21 @@ void ClimateStateResponse::dump_to(std::string &out) const {
   out.append("  swing_mode: ");
   out.append(proto_enum_to_string<enums::ClimateSwingMode>(this->swing_mode));
   out.append("\n");
+
+  out.append("  custom_fan_mode: ");
+  out.append("'").append(this->custom_fan_mode).append("'");
+  out.append("\n");
+
+  out.append("  preset: ");
+  out.append(proto_enum_to_string<enums::ClimatePreset>(this->preset));
+  out.append("\n");
+
+  out.append("  custom_preset: ");
+  out.append("'").append(this->custom_preset).append("'");
+  out.append("\n");
   out.append("}");
 }
+#endif
 bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -2834,11 +3393,11 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
       return true;
     }
     case 10: {
-      this->has_away = value.as_bool();
+      this->has_legacy_away = value.as_bool();
       return true;
     }
     case 11: {
-      this->away = value.as_bool();
+      this->legacy_away = value.as_bool();
       return true;
     }
     case 12: {
@@ -2857,6 +3416,36 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
       this->swing_mode = value.as_enum<enums::ClimateSwingMode>();
       return true;
     }
+    case 16: {
+      this->has_custom_fan_mode = value.as_bool();
+      return true;
+    }
+    case 18: {
+      this->has_preset = value.as_bool();
+      return true;
+    }
+    case 19: {
+      this->preset = value.as_enum<enums::ClimatePreset>();
+      return true;
+    }
+    case 20: {
+      this->has_custom_preset = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ClimateCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 17: {
+      this->custom_fan_mode = value.as_string();
+      return true;
+    }
+    case 21: {
+      this->custom_preset = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -2893,13 +3482,20 @@ void ClimateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(7, this->target_temperature_low);
   buffer.encode_bool(8, this->has_target_temperature_high);
   buffer.encode_float(9, this->target_temperature_high);
-  buffer.encode_bool(10, this->has_away);
-  buffer.encode_bool(11, this->away);
+  buffer.encode_bool(10, this->has_legacy_away);
+  buffer.encode_bool(11, this->legacy_away);
   buffer.encode_bool(12, this->has_fan_mode);
   buffer.encode_enum<enums::ClimateFanMode>(13, this->fan_mode);
   buffer.encode_bool(14, this->has_swing_mode);
   buffer.encode_enum<enums::ClimateSwingMode>(15, this->swing_mode);
+  buffer.encode_bool(16, this->has_custom_fan_mode);
+  buffer.encode_string(17, this->custom_fan_mode);
+  buffer.encode_bool(18, this->has_preset);
+  buffer.encode_enum<enums::ClimatePreset>(19, this->preset);
+  buffer.encode_bool(20, this->has_custom_preset);
+  buffer.encode_string(21, this->custom_preset);
 }
+#ifdef HAS_PROTO_MESSAGE_DUMP
 void ClimateCommandRequest::dump_to(std::string &out) const {
   char buffer[64];
   out.append("ClimateCommandRequest {\n");
@@ -2943,12 +3539,12 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  has_away: ");
-  out.append(YESNO(this->has_away));
+  out.append("  has_legacy_away: ");
+  out.append(YESNO(this->has_legacy_away));
   out.append("\n");
 
-  out.append("  away: ");
-  out.append(YESNO(this->away));
+  out.append("  legacy_away: ");
+  out.append(YESNO(this->legacy_away));
   out.append("\n");
 
   out.append("  has_fan_mode: ");
@@ -2966,8 +3562,414 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   out.append("  swing_mode: ");
   out.append(proto_enum_to_string<enums::ClimateSwingMode>(this->swing_mode));
   out.append("\n");
+
+  out.append("  has_custom_fan_mode: ");
+  out.append(YESNO(this->has_custom_fan_mode));
+  out.append("\n");
+
+  out.append("  custom_fan_mode: ");
+  out.append("'").append(this->custom_fan_mode).append("'");
+  out.append("\n");
+
+  out.append("  has_preset: ");
+  out.append(YESNO(this->has_preset));
+  out.append("\n");
+
+  out.append("  preset: ");
+  out.append(proto_enum_to_string<enums::ClimatePreset>(this->preset));
+  out.append("\n");
+
+  out.append("  has_custom_preset: ");
+  out.append(YESNO(this->has_custom_preset));
+  out.append("\n");
+
+  out.append("  custom_preset: ");
+  out.append("'").append(this->custom_preset).append("'");
+  out.append("\n");
   out.append("}");
 }
+#endif
+bool ListEntitiesNumberResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 9: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesNumberResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesNumberResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 6: {
+      this->min_value = value.as_float();
+      return true;
+    }
+    case 7: {
+      this->max_value = value.as_float();
+      return true;
+    }
+    case 8: {
+      this->step = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_float(6, this->min_value);
+  buffer.encode_float(7, this->max_value);
+  buffer.encode_float(8, this->step);
+  buffer.encode_bool(9, this->disabled_by_default);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesNumberResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("ListEntitiesNumberResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  min_value: ");
+  sprintf(buffer, "%g", this->min_value);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  max_value: ");
+  sprintf(buffer, "%g", this->max_value);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  step: ");
+  sprintf(buffer, "%g", this->step);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool NumberStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 3: {
+      this->missing_state = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool NumberStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 2: {
+      this->state = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NumberStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->state);
+  buffer.encode_bool(3, this->missing_state);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void NumberStateResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("NumberStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  sprintf(buffer, "%g", this->state);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  missing_state: ");
+  out.append(YESNO(this->missing_state));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool NumberCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 2: {
+      this->state = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NumberCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->state);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void NumberCommandRequest::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("NumberCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  sprintf(buffer, "%g", this->state);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool ListEntitiesSelectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 7: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesSelectResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    case 6: {
+      this->options.push_back(value.as_string());
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesSelectResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  for (auto &it : this->options) {
+    buffer.encode_string(6, it, true);
+  }
+  buffer.encode_bool(7, this->disabled_by_default);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesSelectResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("ListEntitiesSelectResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  for (const auto &it : this->options) {
+    out.append("  options: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
+
+  out.append("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool SelectStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 3: {
+      this->missing_state = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SelectStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SelectStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void SelectStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_string(2, this->state);
+  buffer.encode_bool(3, this->missing_state);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void SelectStateResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("SelectStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append("'").append(this->state).append("'");
+  out.append("\n");
+
+  out.append("  missing_state: ");
+  out.append(YESNO(this->missing_state));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool SelectCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 2: {
+      this->state = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool SelectCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void SelectCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_string(2, this->state);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void SelectCommandRequest::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("SelectCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  out.append("'").append(this->state).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -32,14 +32,36 @@ enum FanDirection : uint32_t {
   FAN_DIRECTION_FORWARD = 0,
   FAN_DIRECTION_REVERSE = 1,
 };
+enum ColorMode : uint32_t {
+  COLOR_MODE_UNKNOWN = 0,
+  COLOR_MODE_ON_OFF = 1,
+  COLOR_MODE_BRIGHTNESS = 2,
+  COLOR_MODE_WHITE = 7,
+  COLOR_MODE_COLOR_TEMPERATURE = 11,
+  COLOR_MODE_COLD_WARM_WHITE = 19,
+  COLOR_MODE_RGB = 35,
+  COLOR_MODE_RGB_WHITE = 39,
+  COLOR_MODE_RGB_COLOR_TEMPERATURE = 47,
+  COLOR_MODE_RGB_COLD_WARM_WHITE = 51,
+};
+enum SensorStateClass : uint32_t {
+  STATE_CLASS_NONE = 0,
+  STATE_CLASS_MEASUREMENT = 1,
+};
+enum SensorLastResetType : uint32_t {
+  LAST_RESET_NONE = 0,
+  LAST_RESET_NEVER = 1,
+  LAST_RESET_AUTO = 2,
+};
 enum LogLevel : uint32_t {
   LOG_LEVEL_NONE = 0,
   LOG_LEVEL_ERROR = 1,
   LOG_LEVEL_WARN = 2,
   LOG_LEVEL_INFO = 3,
-  LOG_LEVEL_DEBUG = 4,
-  LOG_LEVEL_VERBOSE = 5,
-  LOG_LEVEL_VERY_VERBOSE = 6,
+  LOG_LEVEL_CONFIG = 4,
+  LOG_LEVEL_DEBUG = 5,
+  LOG_LEVEL_VERBOSE = 6,
+  LOG_LEVEL_VERY_VERBOSE = 7,
 };
 enum ServiceArgType : uint32_t {
   SERVICE_ARG_TYPE_BOOL = 0,
@@ -53,11 +75,12 @@ enum ServiceArgType : uint32_t {
 };
 enum ClimateMode : uint32_t {
   CLIMATE_MODE_OFF = 0,
-  CLIMATE_MODE_AUTO = 1,
+  CLIMATE_MODE_HEAT_COOL = 1,
   CLIMATE_MODE_COOL = 2,
   CLIMATE_MODE_HEAT = 3,
   CLIMATE_MODE_FAN_ONLY = 4,
   CLIMATE_MODE_DRY = 5,
+  CLIMATE_MODE_AUTO = 6,
 };
 enum ClimateFanMode : uint32_t {
   CLIMATE_FAN_ON = 0,
@@ -74,7 +97,7 @@ enum ClimateSwingMode : uint32_t {
   CLIMATE_SWING_OFF = 0,
   CLIMATE_SWING_BOTH = 1,
   CLIMATE_SWING_VERTICAL = 2,
-  CLIMATE_SWINT_HORIZONTAL = 3,
+  CLIMATE_SWING_HORIZONTAL = 3,
 };
 enum ClimateAction : uint32_t {
   CLIMATE_ACTION_OFF = 0,
@@ -84,25 +107,39 @@ enum ClimateAction : uint32_t {
   CLIMATE_ACTION_DRYING = 5,
   CLIMATE_ACTION_FAN = 6,
 };
+enum ClimatePreset : uint32_t {
+  CLIMATE_PRESET_NONE = 0,
+  CLIMATE_PRESET_HOME = 1,
+  CLIMATE_PRESET_AWAY = 2,
+  CLIMATE_PRESET_BOOST = 3,
+  CLIMATE_PRESET_COMFORT = 4,
+  CLIMATE_PRESET_ECO = 5,
+  CLIMATE_PRESET_SLEEP = 6,
+  CLIMATE_PRESET_ACTIVITY = 7,
+};
 
 }  // namespace enums
 
 class HelloRequest : public ProtoMessage {
  public:
-  std::string client_info{};  // NOLINT
+  std::string client_info{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
 class HelloResponse : public ProtoMessage {
  public:
-  uint32_t api_version_major{0};  // NOLINT
-  uint32_t api_version_minor{0};  // NOLINT
-  std::string server_info{};      // NOLINT
+  uint32_t api_version_major{0};
+  uint32_t api_version_minor{0};
+  std::string server_info{};
   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;
@@ -110,18 +147,22 @@ class HelloResponse : public ProtoMessage {
 };
 class ConnectRequest : public ProtoMessage {
  public:
-  std::string password{};  // NOLINT
+  std::string password{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
 class ConnectResponse : public ProtoMessage {
  public:
-  bool invalid_password{false};  // NOLINT
+  bool invalid_password{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;
@@ -129,49 +170,63 @@ class ConnectResponse : public ProtoMessage {
 class DisconnectRequest : 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 DisconnectResponse : 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 PingRequest : 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 PingResponse : 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 DeviceInfoRequest : 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 DeviceInfoResponse : public ProtoMessage {
  public:
-  bool uses_password{false};       // NOLINT
-  std::string name{};              // NOLINT
-  std::string mac_address{};       // NOLINT
-  std::string esphome_version{};   // NOLINT
-  std::string compilation_time{};  // NOLINT
-  std::string model{};             // NOLINT
-  bool has_deep_sleep{false};      // NOLINT
+  bool uses_password{false};
+  std::string name{};
+  std::string mac_address{};
+  std::string esphome_version{};
+  std::string compilation_time{};
+  std::string model{};
+  bool has_deep_sleep{false};
+  std::string project_name{};
+  std::string project_version{};
   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;
@@ -180,34 +235,43 @@ class DeviceInfoResponse : public ProtoMessage {
 class ListEntitiesRequest : 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 ListEntitiesDoneResponse : 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 SubscribeStatesRequest : 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 ListEntitiesBinarySensorResponse : public ProtoMessage {
  public:
-  std::string object_id{};              // NOLINT
-  uint32_t key{0};                      // NOLINT
-  std::string name{};                   // NOLINT
-  std::string unique_id{};              // NOLINT
-  std::string device_class{};           // NOLINT
-  bool is_status_binary_sensor{false};  // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string device_class{};
+  bool is_status_binary_sensor{false};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -216,11 +280,13 @@ class ListEntitiesBinarySensorResponse : public ProtoMessage {
 };
 class BinarySensorStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};            // NOLINT
-  bool state{false};          // NOLINT
-  bool missing_state{false};  // NOLINT
+  uint32_t key{0};
+  bool state{false};
+  bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -228,16 +294,19 @@ class BinarySensorStateResponse : public ProtoMessage {
 };
 class ListEntitiesCoverResponse : public ProtoMessage {
  public:
-  std::string object_id{};        // NOLINT
-  uint32_t key{0};                // NOLINT
-  std::string name{};             // NOLINT
-  std::string unique_id{};        // NOLINT
-  bool assumed_state{false};      // NOLINT
-  bool supports_position{false};  // NOLINT
-  bool supports_tilt{false};      // NOLINT
-  std::string device_class{};     // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  bool assumed_state{false};
+  bool supports_position{false};
+  bool supports_tilt{false};
+  std::string device_class{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -246,13 +315,15 @@ class ListEntitiesCoverResponse : public ProtoMessage {
 };
 class CoverStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};                            // NOLINT
-  enums::LegacyCoverState legacy_state{};     // NOLINT
-  float position{0.0f};                       // NOLINT
-  float tilt{0.0f};                           // NOLINT
-  enums::CoverOperation current_operation{};  // NOLINT
+  uint32_t key{0};
+  enums::LegacyCoverState legacy_state{};
+  float position{0.0f};
+  float tilt{0.0f};
+  enums::CoverOperation current_operation{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -260,16 +331,18 @@ class CoverStateResponse : public ProtoMessage {
 };
 class CoverCommandRequest : public ProtoMessage {
  public:
-  uint32_t key{0};                             // NOLINT
-  bool has_legacy_command{false};              // NOLINT
-  enums::LegacyCoverCommand legacy_command{};  // NOLINT
-  bool has_position{false};                    // NOLINT
-  float position{0.0f};                        // NOLINT
-  bool has_tilt{false};                        // NOLINT
-  float tilt{0.0f};                            // NOLINT
-  bool stop{false};                            // NOLINT
+  uint32_t key{0};
+  bool has_legacy_command{false};
+  enums::LegacyCoverCommand legacy_command{};
+  bool has_position{false};
+  float position{0.0f};
+  bool has_tilt{false};
+  float tilt{0.0f};
+  bool stop{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -277,15 +350,19 @@ class CoverCommandRequest : public ProtoMessage {
 };
 class ListEntitiesFanResponse : public ProtoMessage {
  public:
-  std::string object_id{};           // NOLINT
-  uint32_t key{0};                   // NOLINT
-  std::string name{};                // NOLINT
-  std::string unique_id{};           // NOLINT
-  bool supports_oscillation{false};  // NOLINT
-  bool supports_speed{false};        // NOLINT
-  bool supports_direction{false};    // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  bool supports_oscillation{false};
+  bool supports_speed{false};
+  bool supports_direction{false};
+  int32_t supported_speed_count{0};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -294,13 +371,16 @@ class ListEntitiesFanResponse : public ProtoMessage {
 };
 class FanStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};                  // NOLINT
-  bool state{false};                // NOLINT
-  bool oscillating{false};          // NOLINT
-  enums::FanSpeed speed{};          // NOLINT
-  enums::FanDirection direction{};  // NOLINT
+  uint32_t key{0};
+  bool state{false};
+  bool oscillating{false};
+  enums::FanSpeed speed{};
+  enums::FanDirection direction{};
+  int32_t speed_level{0};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -308,17 +388,21 @@ class FanStateResponse : public ProtoMessage {
 };
 class FanCommandRequest : public ProtoMessage {
  public:
-  uint32_t key{0};                  // NOLINT
-  bool has_state{false};            // NOLINT
-  bool state{false};                // NOLINT
-  bool has_speed{false};            // NOLINT
-  enums::FanSpeed speed{};          // NOLINT
-  bool has_oscillating{false};      // NOLINT
-  bool oscillating{false};          // NOLINT
-  bool has_direction{false};        // NOLINT
-  enums::FanDirection direction{};  // NOLINT
+  uint32_t key{0};
+  bool has_state{false};
+  bool state{false};
+  bool has_speed{false};
+  enums::FanSpeed speed{};
+  bool has_oscillating{false};
+  bool oscillating{false};
+  bool has_direction{false};
+  enums::FanDirection direction{};
+  bool has_speed_level{false};
+  int32_t speed_level{0};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -326,19 +410,23 @@ class FanCommandRequest : public ProtoMessage {
 };
 class ListEntitiesLightResponse : public ProtoMessage {
  public:
-  std::string object_id{};                 // NOLINT
-  uint32_t key{0};                         // NOLINT
-  std::string name{};                      // NOLINT
-  std::string unique_id{};                 // NOLINT
-  bool supports_brightness{false};         // NOLINT
-  bool supports_rgb{false};                // NOLINT
-  bool supports_white_value{false};        // NOLINT
-  bool supports_color_temperature{false};  // NOLINT
-  float min_mireds{0.0f};                  // NOLINT
-  float max_mireds{0.0f};                  // NOLINT
-  std::vector<std::string> effects{};      // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::vector<enums::ColorMode> supported_color_modes{};
+  bool legacy_supports_brightness{false};
+  bool legacy_supports_rgb{false};
+  bool legacy_supports_white_value{false};
+  bool legacy_supports_color_temperature{false};
+  float min_mireds{0.0f};
+  float max_mireds{0.0f};
+  std::vector<std::string> effects{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -347,17 +435,23 @@ class ListEntitiesLightResponse : public ProtoMessage {
 };
 class LightStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};                // NOLINT
-  bool state{false};              // NOLINT
-  float brightness{0.0f};         // NOLINT
-  float red{0.0f};                // NOLINT
-  float green{0.0f};              // NOLINT
-  float blue{0.0f};               // NOLINT
-  float white{0.0f};              // NOLINT
-  float color_temperature{0.0f};  // NOLINT
-  std::string effect{};           // NOLINT
+  uint32_t key{0};
+  bool state{false};
+  float brightness{0.0f};
+  enums::ColorMode color_mode{};
+  float color_brightness{0.0f};
+  float red{0.0f};
+  float green{0.0f};
+  float blue{0.0f};
+  float white{0.0f};
+  float color_temperature{0.0f};
+  float cold_white{0.0f};
+  float warm_white{0.0f};
+  std::string effect{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -366,27 +460,37 @@ class LightStateResponse : public ProtoMessage {
 };
 class LightCommandRequest : public ProtoMessage {
  public:
-  uint32_t key{0};                    // NOLINT
-  bool has_state{false};              // NOLINT
-  bool state{false};                  // NOLINT
-  bool has_brightness{false};         // NOLINT
-  float brightness{0.0f};             // NOLINT
-  bool has_rgb{false};                // NOLINT
-  float red{0.0f};                    // NOLINT
-  float green{0.0f};                  // NOLINT
-  float blue{0.0f};                   // NOLINT
-  bool has_white{false};              // NOLINT
-  float white{0.0f};                  // NOLINT
-  bool has_color_temperature{false};  // NOLINT
-  float color_temperature{0.0f};      // NOLINT
-  bool has_transition_length{false};  // NOLINT
-  uint32_t transition_length{0};      // NOLINT
-  bool has_flash_length{false};       // NOLINT
-  uint32_t flash_length{0};           // NOLINT
-  bool has_effect{false};             // NOLINT
-  std::string effect{};               // NOLINT
+  uint32_t key{0};
+  bool has_state{false};
+  bool state{false};
+  bool has_brightness{false};
+  float brightness{0.0f};
+  bool has_color_mode{false};
+  enums::ColorMode color_mode{};
+  bool has_color_brightness{false};
+  float color_brightness{0.0f};
+  bool has_rgb{false};
+  float red{0.0f};
+  float green{0.0f};
+  float blue{0.0f};
+  bool has_white{false};
+  float white{0.0f};
+  bool has_color_temperature{false};
+  float color_temperature{0.0f};
+  bool has_cold_white{false};
+  float cold_white{0.0f};
+  bool has_warm_white{false};
+  float warm_white{0.0f};
+  bool has_transition_length{false};
+  uint32_t transition_length{0};
+  bool has_flash_length{false};
+  uint32_t flash_length{0};
+  bool has_effect{false};
+  std::string effect{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -395,16 +499,22 @@ class LightCommandRequest : public ProtoMessage {
 };
 class ListEntitiesSensorResponse : public ProtoMessage {
  public:
-  std::string object_id{};            // NOLINT
-  uint32_t key{0};                    // NOLINT
-  std::string name{};                 // NOLINT
-  std::string unique_id{};            // NOLINT
-  std::string icon{};                 // NOLINT
-  std::string unit_of_measurement{};  // NOLINT
-  int32_t accuracy_decimals{0};       // NOLINT
-  bool force_update{false};           // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  std::string unit_of_measurement{};
+  int32_t accuracy_decimals{0};
+  bool force_update{false};
+  std::string device_class{};
+  enums::SensorStateClass state_class{};
+  enums::SensorLastResetType last_reset_type{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -413,11 +523,13 @@ class ListEntitiesSensorResponse : public ProtoMessage {
 };
 class SensorStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};            // NOLINT
-  float state{0.0f};          // NOLINT
-  bool missing_state{false};  // NOLINT
+  uint32_t key{0};
+  float state{0.0f};
+  bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -425,14 +537,17 @@ class SensorStateResponse : public ProtoMessage {
 };
 class ListEntitiesSwitchResponse : public ProtoMessage {
  public:
-  std::string object_id{};    // NOLINT
-  uint32_t key{0};            // NOLINT
-  std::string name{};         // NOLINT
-  std::string unique_id{};    // NOLINT
-  std::string icon{};         // NOLINT
-  bool assumed_state{false};  // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool assumed_state{false};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -441,10 +556,12 @@ class ListEntitiesSwitchResponse : public ProtoMessage {
 };
 class SwitchStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};    // NOLINT
-  bool state{false};  // NOLINT
+  uint32_t key{0};
+  bool state{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -452,10 +569,12 @@ class SwitchStateResponse : public ProtoMessage {
 };
 class SwitchCommandRequest : public ProtoMessage {
  public:
-  uint32_t key{0};    // NOLINT
-  bool state{false};  // NOLINT
+  uint32_t key{0};
+  bool state{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -463,25 +582,31 @@ class SwitchCommandRequest : public ProtoMessage {
 };
 class ListEntitiesTextSensorResponse : public ProtoMessage {
  public:
-  std::string object_id{};  // NOLINT
-  uint32_t key{0};          // NOLINT
-  std::string name{};       // NOLINT
-  std::string unique_id{};  // NOLINT
-  std::string icon{};       // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class TextSensorStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};            // NOLINT
-  std::string state{};        // NOLINT
-  bool missing_state{false};  // NOLINT
+  uint32_t key{0};
+  std::string state{};
+  bool missing_state{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -490,22 +615,25 @@ class TextSensorStateResponse : public ProtoMessage {
 };
 class SubscribeLogsRequest : public ProtoMessage {
  public:
-  enums::LogLevel level{};  // NOLINT
-  bool dump_config{false};  // NOLINT
+  enums::LogLevel level{};
+  bool dump_config{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 SubscribeLogsResponse : public ProtoMessage {
  public:
-  enums::LogLevel level{};  // NOLINT
-  std::string tag{};        // NOLINT
-  std::string message{};    // NOLINT
-  bool send_failed{false};  // NOLINT
+  enums::LogLevel level{};
+  std::string message{};
+  bool send_failed{false};
   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;
@@ -514,29 +642,35 @@ class SubscribeLogsResponse : public ProtoMessage {
 class SubscribeHomeassistantServicesRequest : 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 HomeassistantServiceMap : public ProtoMessage {
  public:
-  std::string key{};    // NOLINT
-  std::string value{};  // NOLINT
+  std::string key{};
+  std::string value{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
 class HomeassistantServiceResponse : public ProtoMessage {
  public:
-  std::string service{};                                 // NOLINT
-  std::vector<HomeassistantServiceMap> data{};           // NOLINT
-  std::vector<HomeassistantServiceMap> data_template{};  // NOLINT
-  std::vector<HomeassistantServiceMap> variables{};      // NOLINT
-  bool is_event{false};                                  // NOLINT
+  std::string service{};
+  std::vector<HomeassistantServiceMap> data{};
+  std::vector<HomeassistantServiceMap> data_template{};
+  std::vector<HomeassistantServiceMap> variables{};
+  bool is_event{false};
   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;
@@ -545,25 +679,33 @@ class HomeassistantServiceResponse : public ProtoMessage {
 class SubscribeHomeAssistantStatesRequest : 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 SubscribeHomeAssistantStateResponse : public ProtoMessage {
  public:
-  std::string entity_id{};  // NOLINT
+  std::string entity_id{};
+  std::string attribute{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
 };
 class HomeAssistantStateResponse : public ProtoMessage {
  public:
-  std::string entity_id{};  // NOLINT
-  std::string state{};      // NOLINT
+  std::string entity_id{};
+  std::string state{};
+  std::string attribute{};
   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;
@@ -571,25 +713,31 @@ class HomeAssistantStateResponse : public ProtoMessage {
 class GetTimeRequest : 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 GetTimeResponse : public ProtoMessage {
  public:
-  uint32_t epoch_seconds{0};  // NOLINT
+  uint32_t epoch_seconds{0};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
 };
 class ListEntitiesServicesArgument : public ProtoMessage {
  public:
-  std::string name{};            // NOLINT
-  enums::ServiceArgType type{};  // NOLINT
+  std::string name{};
+  enums::ServiceArgType type{};
   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;
@@ -597,11 +745,13 @@ class ListEntitiesServicesArgument : public ProtoMessage {
 };
 class ListEntitiesServicesResponse : public ProtoMessage {
  public:
-  std::string name{};                                // NOLINT
-  uint32_t key{0};                                   // NOLINT
-  std::vector<ListEntitiesServicesArgument> args{};  // NOLINT
+  std::string name{};
+  uint32_t key{0};
+  std::vector<ListEntitiesServicesArgument> args{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -609,17 +759,19 @@ class ListEntitiesServicesResponse : public ProtoMessage {
 };
 class ExecuteServiceArgument : public ProtoMessage {
  public:
-  bool bool_{false};                        // NOLINT
-  int32_t legacy_int{0};                    // NOLINT
-  float float_{0.0f};                       // NOLINT
-  std::string string_{};                    // NOLINT
-  int32_t int_{0};                          // NOLINT
-  std::vector<bool> bool_array{};           // NOLINT
-  std::vector<int32_t> int_array{};         // NOLINT
-  std::vector<float> float_array{};         // NOLINT
-  std::vector<std::string> string_array{};  // NOLINT
+  bool bool_{false};
+  int32_t legacy_int{0};
+  float float_{0.0f};
+  std::string string_{};
+  int32_t int_{0};
+  std::vector<bool> bool_array{};
+  std::vector<int32_t> int_array{};
+  std::vector<float> float_array{};
+  std::vector<std::string> string_array{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -628,10 +780,12 @@ class ExecuteServiceArgument : public ProtoMessage {
 };
 class ExecuteServiceRequest : public ProtoMessage {
  public:
-  uint32_t key{0};                             // NOLINT
-  std::vector<ExecuteServiceArgument> args{};  // NOLINT
+  uint32_t key{0};
+  std::vector<ExecuteServiceArgument> args{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -639,24 +793,30 @@ class ExecuteServiceRequest : public ProtoMessage {
 };
 class ListEntitiesCameraResponse : public ProtoMessage {
  public:
-  std::string object_id{};  // NOLINT
-  uint32_t key{0};          // NOLINT
-  std::string name{};       // NOLINT
-  std::string unique_id{};  // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class CameraImageResponse : public ProtoMessage {
  public:
-  uint32_t key{0};     // NOLINT
-  std::string data{};  // NOLINT
-  bool done{false};    // NOLINT
+  uint32_t key{0};
+  std::string data{};
+  bool done{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -665,32 +825,40 @@ class CameraImageResponse : public ProtoMessage {
 };
 class CameraImageRequest : public ProtoMessage {
  public:
-  bool single{false};  // NOLINT
-  bool stream{false};  // NOLINT
+  bool single{false};
+  bool stream{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 ListEntitiesClimateResponse : public ProtoMessage {
  public:
-  std::string object_id{};                                       // NOLINT
-  uint32_t key{0};                                               // NOLINT
-  std::string name{};                                            // NOLINT
-  std::string unique_id{};                                       // NOLINT
-  bool supports_current_temperature{false};                      // NOLINT
-  bool supports_two_point_target_temperature{false};             // NOLINT
-  std::vector<enums::ClimateMode> supported_modes{};             // NOLINT
-  float visual_min_temperature{0.0f};                            // NOLINT
-  float visual_max_temperature{0.0f};                            // NOLINT
-  float visual_temperature_step{0.0f};                           // NOLINT
-  bool supports_away{false};                                     // NOLINT
-  bool supports_action{false};                                   // NOLINT
-  std::vector<enums::ClimateFanMode> supported_fan_modes{};      // NOLINT
-  std::vector<enums::ClimateSwingMode> supported_swing_modes{};  // NOLINT
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  bool supports_current_temperature{false};
+  bool supports_two_point_target_temperature{false};
+  std::vector<enums::ClimateMode> supported_modes{};
+  float visual_min_temperature{0.0f};
+  float visual_max_temperature{0.0f};
+  float visual_temperature_step{0.0f};
+  bool legacy_supports_away{false};
+  bool supports_action{false};
+  std::vector<enums::ClimateFanMode> supported_fan_modes{};
+  std::vector<enums::ClimateSwingMode> supported_swing_modes{};
+  std::vector<std::string> supported_custom_fan_modes{};
+  std::vector<enums::ClimatePreset> supported_presets{};
+  std::vector<std::string> supported_custom_presets{};
+  bool disabled_by_default{false};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
@@ -699,47 +867,156 @@ class ListEntitiesClimateResponse : public ProtoMessage {
 };
 class ClimateStateResponse : public ProtoMessage {
  public:
-  uint32_t key{0};                       // NOLINT
-  enums::ClimateMode mode{};             // NOLINT
-  float current_temperature{0.0f};       // NOLINT
-  float target_temperature{0.0f};        // NOLINT
-  float target_temperature_low{0.0f};    // NOLINT
-  float target_temperature_high{0.0f};   // NOLINT
-  bool away{false};                      // NOLINT
-  enums::ClimateAction action{};         // NOLINT
-  enums::ClimateFanMode fan_mode{};      // NOLINT
-  enums::ClimateSwingMode swing_mode{};  // NOLINT
+  uint32_t key{0};
+  enums::ClimateMode mode{};
+  float current_temperature{0.0f};
+  float target_temperature{0.0f};
+  float target_temperature_low{0.0f};
+  float target_temperature_high{0.0f};
+  bool legacy_away{false};
+  enums::ClimateAction action{};
+  enums::ClimateFanMode fan_mode{};
+  enums::ClimateSwingMode swing_mode{};
+  std::string custom_fan_mode{};
+  enums::ClimatePreset preset{};
+  std::string custom_preset{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
 class ClimateCommandRequest : public ProtoMessage {
  public:
-  uint32_t key{0};                          // NOLINT
-  bool has_mode{false};                     // NOLINT
-  enums::ClimateMode mode{};                // NOLINT
-  bool has_target_temperature{false};       // NOLINT
-  float target_temperature{0.0f};           // NOLINT
-  bool has_target_temperature_low{false};   // NOLINT
-  float target_temperature_low{0.0f};       // NOLINT
-  bool has_target_temperature_high{false};  // NOLINT
-  float target_temperature_high{0.0f};      // NOLINT
-  bool has_away{false};                     // NOLINT
-  bool away{false};                         // NOLINT
-  bool has_fan_mode{false};                 // NOLINT
-  enums::ClimateFanMode fan_mode{};         // NOLINT
-  bool has_swing_mode{false};               // NOLINT
-  enums::ClimateSwingMode swing_mode{};     // NOLINT
+  uint32_t key{0};
+  bool has_mode{false};
+  enums::ClimateMode mode{};
+  bool has_target_temperature{false};
+  float target_temperature{0.0f};
+  bool has_target_temperature_low{false};
+  float target_temperature_low{0.0f};
+  bool has_target_temperature_high{false};
+  float target_temperature_high{0.0f};
+  bool has_legacy_away{false};
+  bool legacy_away{false};
+  bool has_fan_mode{false};
+  enums::ClimateFanMode fan_mode{};
+  bool has_swing_mode{false};
+  enums::ClimateSwingMode swing_mode{};
+  bool has_custom_fan_mode{false};
+  std::string custom_fan_mode{};
+  bool has_preset{false};
+  enums::ClimatePreset preset{};
+  bool has_custom_preset{false};
+  std::string custom_preset{};
   void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesNumberResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  float min_value{0.0f};
+  float max_value{0.0f};
+  float step{0.0f};
+  bool disabled_by_default{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class NumberStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  float state{0.0f};
+  bool missing_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
 
  protected:
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class NumberCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  float state{0.0f};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+};
+class ListEntitiesSelectResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  std::vector<std::string> options{};
+  bool disabled_by_default{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SelectStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::string state{};
+  bool missing_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SelectCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::string state{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -6,61 +6,85 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.service";
+static const char *const TAG = "api.service";
 
 bool APIServerConnectionBase::send_hello_response(const HelloResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_hello_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<HelloResponse>(msg, 2);
 }
 bool APIServerConnectionBase::send_connect_response(const ConnectResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_connect_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ConnectResponse>(msg, 4);
 }
 bool APIServerConnectionBase::send_disconnect_request(const DisconnectRequest &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_disconnect_request: %s", msg.dump().c_str());
+#endif
   return this->send_message_<DisconnectRequest>(msg, 5);
 }
 bool APIServerConnectionBase::send_disconnect_response(const DisconnectResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_disconnect_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<DisconnectResponse>(msg, 6);
 }
 bool APIServerConnectionBase::send_ping_request(const PingRequest &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_ping_request: %s", msg.dump().c_str());
+#endif
   return this->send_message_<PingRequest>(msg, 7);
 }
 bool APIServerConnectionBase::send_ping_response(const PingResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_ping_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<PingResponse>(msg, 8);
 }
 bool APIServerConnectionBase::send_device_info_response(const DeviceInfoResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_device_info_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<DeviceInfoResponse>(msg, 10);
 }
 bool APIServerConnectionBase::send_list_entities_done_response(const ListEntitiesDoneResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_done_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesDoneResponse>(msg, 19);
 }
 #ifdef USE_BINARY_SENSOR
 bool APIServerConnectionBase::send_list_entities_binary_sensor_response(const ListEntitiesBinarySensorResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_binary_sensor_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesBinarySensorResponse>(msg, 12);
 }
 #endif
 #ifdef USE_BINARY_SENSOR
 bool APIServerConnectionBase::send_binary_sensor_state_response(const BinarySensorStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_binary_sensor_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<BinarySensorStateResponse>(msg, 21);
 }
 #endif
 #ifdef USE_COVER
 bool APIServerConnectionBase::send_list_entities_cover_response(const ListEntitiesCoverResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_cover_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesCoverResponse>(msg, 13);
 }
 #endif
 #ifdef USE_COVER
 bool APIServerConnectionBase::send_cover_state_response(const CoverStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_cover_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<CoverStateResponse>(msg, 22);
 }
 #endif
@@ -68,13 +92,17 @@ bool APIServerConnectionBase::send_cover_state_response(const CoverStateResponse
 #endif
 #ifdef USE_FAN
 bool APIServerConnectionBase::send_list_entities_fan_response(const ListEntitiesFanResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_fan_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesFanResponse>(msg, 14);
 }
 #endif
 #ifdef USE_FAN
 bool APIServerConnectionBase::send_fan_state_response(const FanStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_fan_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<FanStateResponse>(msg, 23);
 }
 #endif
@@ -82,13 +110,17 @@ bool APIServerConnectionBase::send_fan_state_response(const FanStateResponse &ms
 #endif
 #ifdef USE_LIGHT
 bool APIServerConnectionBase::send_list_entities_light_response(const ListEntitiesLightResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_light_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesLightResponse>(msg, 15);
 }
 #endif
 #ifdef USE_LIGHT
 bool APIServerConnectionBase::send_light_state_response(const LightStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_light_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<LightStateResponse>(msg, 24);
 }
 #endif
@@ -96,25 +128,33 @@ bool APIServerConnectionBase::send_light_state_response(const LightStateResponse
 #endif
 #ifdef USE_SENSOR
 bool APIServerConnectionBase::send_list_entities_sensor_response(const ListEntitiesSensorResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_sensor_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesSensorResponse>(msg, 16);
 }
 #endif
 #ifdef USE_SENSOR
 bool APIServerConnectionBase::send_sensor_state_response(const SensorStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_sensor_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<SensorStateResponse>(msg, 25);
 }
 #endif
 #ifdef USE_SWITCH
 bool APIServerConnectionBase::send_list_entities_switch_response(const ListEntitiesSwitchResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_switch_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesSwitchResponse>(msg, 17);
 }
 #endif
 #ifdef USE_SWITCH
 bool APIServerConnectionBase::send_switch_state_response(const SwitchStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_switch_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<SwitchStateResponse>(msg, 26);
 }
 #endif
@@ -122,13 +162,17 @@ bool APIServerConnectionBase::send_switch_state_response(const SwitchStateRespon
 #endif
 #ifdef USE_TEXT_SENSOR
 bool APIServerConnectionBase::send_list_entities_text_sensor_response(const ListEntitiesTextSensorResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_text_sensor_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesTextSensorResponse>(msg, 18);
 }
 #endif
 #ifdef USE_TEXT_SENSOR
 bool APIServerConnectionBase::send_text_sensor_state_response(const TextSensorStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_text_sensor_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<TextSensorStateResponse>(msg, 27);
 }
 #endif
@@ -136,35 +180,49 @@ bool APIServerConnectionBase::send_subscribe_logs_response(const SubscribeLogsRe
   return this->send_message_<SubscribeLogsResponse>(msg, 29);
 }
 bool APIServerConnectionBase::send_homeassistant_service_response(const HomeassistantServiceResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_homeassistant_service_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<HomeassistantServiceResponse>(msg, 35);
 }
 bool APIServerConnectionBase::send_subscribe_home_assistant_state_response(
     const SubscribeHomeAssistantStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_subscribe_home_assistant_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<SubscribeHomeAssistantStateResponse>(msg, 39);
 }
 bool APIServerConnectionBase::send_get_time_request(const GetTimeRequest &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_get_time_request: %s", msg.dump().c_str());
+#endif
   return this->send_message_<GetTimeRequest>(msg, 36);
 }
 bool APIServerConnectionBase::send_get_time_response(const GetTimeResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_get_time_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<GetTimeResponse>(msg, 37);
 }
 bool APIServerConnectionBase::send_list_entities_services_response(const ListEntitiesServicesResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_services_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesServicesResponse>(msg, 41);
 }
 #ifdef USE_ESP32_CAMERA
 bool APIServerConnectionBase::send_list_entities_camera_response(const ListEntitiesCameraResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_camera_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesCameraResponse>(msg, 43);
 }
 #endif
 #ifdef USE_ESP32_CAMERA
 bool APIServerConnectionBase::send_camera_image_response(const CameraImageResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_camera_image_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<CameraImageResponse>(msg, 44);
 }
 #endif
@@ -172,87 +230,147 @@ bool APIServerConnectionBase::send_camera_image_response(const CameraImageRespon
 #endif
 #ifdef USE_CLIMATE
 bool APIServerConnectionBase::send_list_entities_climate_response(const ListEntitiesClimateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_list_entities_climate_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ListEntitiesClimateResponse>(msg, 46);
 }
 #endif
 #ifdef USE_CLIMATE
 bool APIServerConnectionBase::send_climate_state_response(const ClimateStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
   ESP_LOGVV(TAG, "send_climate_state_response: %s", msg.dump().c_str());
+#endif
   return this->send_message_<ClimateStateResponse>(msg, 47);
 }
 #endif
 #ifdef USE_CLIMATE
 #endif
+#ifdef USE_NUMBER
+bool APIServerConnectionBase::send_list_entities_number_response(const ListEntitiesNumberResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_number_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesNumberResponse>(msg, 49);
+}
+#endif
+#ifdef USE_NUMBER
+bool APIServerConnectionBase::send_number_state_response(const NumberStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_number_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<NumberStateResponse>(msg, 50);
+}
+#endif
+#ifdef USE_NUMBER
+#endif
+#ifdef USE_SELECT
+bool APIServerConnectionBase::send_list_entities_select_response(const ListEntitiesSelectResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_select_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesSelectResponse>(msg, 52);
+}
+#endif
+#ifdef USE_SELECT
+bool APIServerConnectionBase::send_select_state_response(const SelectStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_select_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<SelectStateResponse>(msg, 53);
+}
+#endif
+#ifdef USE_SELECT
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
       HelloRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_hello_request: %s", msg.dump().c_str());
+#endif
       this->on_hello_request(msg);
       break;
     }
     case 3: {
       ConnectRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_connect_request: %s", msg.dump().c_str());
+#endif
       this->on_connect_request(msg);
       break;
     }
     case 5: {
       DisconnectRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_disconnect_request: %s", msg.dump().c_str());
+#endif
       this->on_disconnect_request(msg);
       break;
     }
     case 6: {
       DisconnectResponse msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_disconnect_response: %s", msg.dump().c_str());
+#endif
       this->on_disconnect_response(msg);
       break;
     }
     case 7: {
       PingRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_ping_request: %s", msg.dump().c_str());
+#endif
       this->on_ping_request(msg);
       break;
     }
     case 8: {
       PingResponse msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_ping_response: %s", msg.dump().c_str());
+#endif
       this->on_ping_response(msg);
       break;
     }
     case 9: {
       DeviceInfoRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_device_info_request: %s", msg.dump().c_str());
+#endif
       this->on_device_info_request(msg);
       break;
     }
     case 11: {
       ListEntitiesRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_list_entities_request: %s", msg.dump().c_str());
+#endif
       this->on_list_entities_request(msg);
       break;
     }
     case 20: {
       SubscribeStatesRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_states_request: %s", msg.dump().c_str());
+#endif
       this->on_subscribe_states_request(msg);
       break;
     }
     case 28: {
       SubscribeLogsRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_logs_request: %s", msg.dump().c_str());
+#endif
       this->on_subscribe_logs_request(msg);
       break;
     }
@@ -260,7 +378,9 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_COVER
       CoverCommandRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_cover_command_request: %s", msg.dump().c_str());
+#endif
       this->on_cover_command_request(msg);
 #endif
       break;
@@ -269,7 +389,9 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_FAN
       FanCommandRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_fan_command_request: %s", msg.dump().c_str());
+#endif
       this->on_fan_command_request(msg);
 #endif
       break;
@@ -278,7 +400,9 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_LIGHT
       LightCommandRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_light_command_request: %s", msg.dump().c_str());
+#endif
       this->on_light_command_request(msg);
 #endif
       break;
@@ -287,7 +411,9 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_SWITCH
       SwitchCommandRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_switch_command_request: %s", msg.dump().c_str());
+#endif
       this->on_switch_command_request(msg);
 #endif
       break;
@@ -295,42 +421,54 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
     case 34: {
       SubscribeHomeassistantServicesRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_homeassistant_services_request: %s", msg.dump().c_str());
+#endif
       this->on_subscribe_homeassistant_services_request(msg);
       break;
     }
     case 36: {
       GetTimeRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_get_time_request: %s", msg.dump().c_str());
+#endif
       this->on_get_time_request(msg);
       break;
     }
     case 37: {
       GetTimeResponse msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_get_time_response: %s", msg.dump().c_str());
+#endif
       this->on_get_time_response(msg);
       break;
     }
     case 38: {
       SubscribeHomeAssistantStatesRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_home_assistant_states_request: %s", msg.dump().c_str());
+#endif
       this->on_subscribe_home_assistant_states_request(msg);
       break;
     }
     case 40: {
       HomeAssistantStateResponse msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_home_assistant_state_response: %s", msg.dump().c_str());
+#endif
       this->on_home_assistant_state_response(msg);
       break;
     }
     case 42: {
       ExecuteServiceRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_execute_service_request: %s", msg.dump().c_str());
+#endif
       this->on_execute_service_request(msg);
       break;
     }
@@ -338,7 +476,9 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_ESP32_CAMERA
       CameraImageRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_camera_image_request: %s", msg.dump().c_str());
+#endif
       this->on_camera_image_request(msg);
 #endif
       break;
@@ -347,8 +487,32 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #ifdef USE_CLIMATE
       ClimateCommandRequest msg;
       msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_climate_command_request: %s", msg.dump().c_str());
+#endif
       this->on_climate_command_request(msg);
+#endif
+      break;
+    }
+    case 51: {
+#ifdef USE_NUMBER
+      NumberCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_number_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_number_command_request(msg);
+#endif
+      break;
+    }
+    case 54: {
+#ifdef USE_SELECT
+      SelectCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_select_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_select_command_request(msg);
 #endif
       break;
     }
@@ -547,6 +711,32 @@ void APIServerConnection::on_climate_command_request(const ClimateCommandRequest
   this->climate_command(msg);
 }
 #endif
+#ifdef USE_NUMBER
+void APIServerConnection::on_number_command_request(const NumberCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->number_command(msg);
+}
+#endif
+#ifdef USE_SELECT
+void APIServerConnection::on_select_command_request(const SelectCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->select_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -111,6 +111,24 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_CLIMATE
   virtual void on_climate_command_request(const ClimateCommandRequest &value){};
+#endif
+#ifdef USE_NUMBER
+  bool send_list_entities_number_response(const ListEntitiesNumberResponse &msg);
+#endif
+#ifdef USE_NUMBER
+  bool send_number_state_response(const NumberStateResponse &msg);
+#endif
+#ifdef USE_NUMBER
+  virtual void on_number_command_request(const NumberCommandRequest &value){};
+#endif
+#ifdef USE_SELECT
+  bool send_list_entities_select_response(const ListEntitiesSelectResponse &msg);
+#endif
+#ifdef USE_SELECT
+  bool send_select_state_response(const SelectStateResponse &msg);
+#endif
+#ifdef USE_SELECT
+  virtual void on_select_command_request(const SelectCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -147,6 +165,12 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_CLIMATE
   virtual void climate_command(const ClimateCommandRequest &msg) = 0;
+#endif
+#ifdef USE_NUMBER
+  virtual void number_command(const NumberCommandRequest &msg) = 0;
+#endif
+#ifdef USE_SELECT
+  virtual void select_command(const SelectCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -179,6 +203,12 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_CLIMATE
   void on_climate_command_request(const ClimateCommandRequest &msg) override;
 #endif
+#ifdef USE_NUMBER
+  void on_number_command_request(const NumberCommandRequest &msg) override;
+#endif
+#ifdef USE_SELECT
+  void on_select_command_request(const SelectCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api

esphome/components/api/api_server.cpp

@@ -15,7 +15,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api";
+static const char *const TAG = "api";
 
 // APIServer
 void APIServer::setup() {
@@ -180,7 +180,7 @@ void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
 #endif
 
 #ifdef USE_TEXT_SENSOR
-void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, std::string state) {
+void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
   if (obj->is_internal())
     return;
   for (auto *c : this->clients_)
@@ -197,9 +197,27 @@ void APIServer::on_climate_update(climate::Climate *obj) {
 }
 #endif
 
+#ifdef USE_NUMBER
+void APIServer::on_number_update(number::Number *obj, float state) {
+  if (obj->is_internal())
+    return;
+  for (auto *c : this->clients_)
+    c->send_number_state(obj, state);
+}
+#endif
+
+#ifdef USE_SELECT
+void APIServer::on_select_update(select::Select *obj, const std::string &state) {
+  if (obj->is_internal())
+    return;
+  for (auto *c : this->clients_)
+    c->send_select_state(obj, state);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
-APIServer *global_api_server = nullptr;
+APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void APIServer::set_password(const std::string &password) { this->password_ = password; }
 void APIServer::send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
@@ -208,9 +226,11 @@ void APIServer::send_homeassistant_service_call(const HomeassistantServiceRespon
   }
 }
 APIServer::APIServer() { global_api_server = this; }
-void APIServer::subscribe_home_assistant_state(std::string entity_id, std::function<void(std::string)> f) {
+void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                               std::function<void(std::string)> f) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
       .entity_id = std::move(entity_id),
+      .attribute = std::move(attribute),
       .callback = std::move(f),
   });
 }

esphome/components/api/api_server.h

@@ -9,7 +9,6 @@
 #include "util.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
-#include "homeassistant_service.h"
 #include "user_services.h"
 
 #ifdef ARDUINO_ARCH_ESP32
@@ -56,10 +55,16 @@ class APIServer : public Component, public Controller {
   void on_switch_update(switch_::Switch *obj, bool state) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj, std::string state) override;
+  void on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) override;
 #endif
 #ifdef USE_CLIMATE
   void on_climate_update(climate::Climate *obj) override;
+#endif
+#ifdef USE_NUMBER
+  void on_number_update(number::Number *obj, float state) override;
+#endif
+#ifdef USE_SELECT
+  void on_select_update(select::Select *obj, const std::string &state) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
@@ -71,10 +76,12 @@ class APIServer : public Component, public Controller {
 
   struct HomeAssistantStateSubscription {
     std::string entity_id;
+    optional<std::string> attribute;
     std::function<void(std::string)> callback;
   };
 
-  void subscribe_home_assistant_state(std::string entity_id, std::function<void(std::string)> f);
+  void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                      std::function<void(std::string)> f);
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
   const std::vector<UserServiceDescriptor *> &get_user_services() const { return this->user_services_; }
 
@@ -89,7 +96,7 @@ class APIServer : public Component, public Controller {
   std::vector<UserServiceDescriptor *> user_services_;
 };
 
-extern APIServer *global_api_server;
+extern APIServer *global_api_server;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 template<typename... Ts> class APIConnectedCondition : public Condition<Ts...> {
  public:

esphome/components/api/custom_api_device.h

@@ -76,13 +76,13 @@ class CustomAPIDevice {
     global_api_server->register_user_service(service);
   }
 
-  /** Subscribe to the state of an entity from Home Assistant.
+  /** Subscribe to the state (or attribute state) of an entity from Home Assistant.
    *
    * Usage:
    *
    * ```cpp
    * void setup() override {
-   *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "sensor.weather_forecast");
+   *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "climate.kitchen", "current_temperature");
    * }
    *
    * void on_state_changed(std::string state) {
@@ -93,17 +93,19 @@ class CustomAPIDevice {
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
    * @param callback The member function to call when the entity state changes.
    * @param entity_id The entity_id to track.
+   * @param attribute The entity state attribute to track.
    */
   template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id) {
+  void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
+                                     const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, f);
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
   }
 
-  /** Subscribe to the state of an entity from Home Assistant.
+  /** Subscribe to the state (or attribute state) of an entity from Home Assistant.
    *
    * Usage:
-   *
+   *å
    * ```cpp
    * void setup() override {
    *   subscribe_homeassistant_state(&CustomNativeAPI::on_state_changed, "sensor.weather_forecast");
@@ -117,11 +119,13 @@ class CustomAPIDevice {
    * @tparam T The class type creating the service, automatically deduced from the function pointer.
    * @param callback The member function to call when the entity state changes.
    * @param entity_id The entity_id to track.
+   * @param attribute The entity state attribute to track.
    */
   template<typename T>
-  void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id) {
+  void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
+                                     const std::string &attribute = "") {
     auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
-    global_api_server->subscribe_home_assistant_state(entity_id, f);
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
   }
 
   /** Call a Home Assistant service from ESPHome.

esphome/components/api/list_entities.cpp

@@ -51,5 +51,13 @@ bool ListEntitiesIterator::on_camera(esp32_camera::ESP32Camera *camera) {
 bool ListEntitiesIterator::on_climate(climate::Climate *climate) { return this->client_->send_climate_info(climate); }
 #endif
 
+#ifdef USE_NUMBER
+bool ListEntitiesIterator::on_number(number::Number *number) { return this->client_->send_number_info(number); }
+#endif
+
+#ifdef USE_SELECT
+bool ListEntitiesIterator::on_select(select::Select *select) { return this->client_->send_select_info(select); }
+#endif
+
 }  // namespace api
 }  // namespace esphome

esphome/components/api/list_entities.h

@@ -39,6 +39,12 @@ class ListEntitiesIterator : public ComponentIterator {
 #endif
 #ifdef USE_CLIMATE
   bool on_climate(climate::Climate *climate) override;
+#endif
+#ifdef USE_NUMBER
+  bool on_number(number::Number *number) override;
+#endif
+#ifdef USE_SELECT
+  bool on_select(select::Select *select) override;
 #endif
   bool on_end() override;
 

esphome/components/api/proto.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.proto";
+static const char *const TAG = "api.proto";
 
 void ProtoMessage::decode(const uint8_t *buffer, size_t length) {
   uint32_t i = 0;
@@ -62,8 +62,7 @@ void ProtoMessage::decode(const uint8_t *buffer, size_t length) {
           error = true;
           break;
         }
-        uint32_t val = (uint32_t(buffer[i]) << 0) | (uint32_t(buffer[i + 1]) << 8) | (uint32_t(buffer[i + 2]) << 16) |
-                       (uint32_t(buffer[i + 3]) << 24);
+        uint32_t val = encode_uint32(buffer[i + 3], buffer[i + 2], buffer[i + 1], buffer[i]);
         if (!this->decode_32bit(field_id, Proto32Bit(val))) {
           ESP_LOGV(TAG, "Cannot decode 32-bit field %u with value %u!", field_id, val);
         }
@@ -81,11 +80,13 @@ void ProtoMessage::decode(const uint8_t *buffer, size_t length) {
   }
 }
 
+#ifdef HAS_PROTO_MESSAGE_DUMP
 std::string ProtoMessage::dump() const {
   std::string out;
   this->dump_to(out);
   return out;
 }
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/proto.h

@@ -1,8 +1,13 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
 
+#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
+#define HAS_PROTO_MESSAGE_DUMP
+#endif
+
 namespace esphome {
 namespace api {
 
@@ -243,8 +248,10 @@ class ProtoMessage {
  public:
   virtual void encode(ProtoWriteBuffer buffer) const = 0;
   void decode(const uint8_t *buffer, size_t length);
+#ifdef HAS_PROTO_MESSAGE_DUMP
   std::string dump() const;
   virtual void dump_to(std::string &out) const = 0;
+#endif
 
  protected:
   virtual bool decode_varint(uint32_t field_id, ProtoVarInt value) { return false; }

esphome/components/api/subscribe_state.cpp

@@ -37,6 +37,16 @@ bool InitialStateIterator::on_text_sensor(text_sensor::TextSensor *text_sensor)
 #ifdef USE_CLIMATE
 bool InitialStateIterator::on_climate(climate::Climate *climate) { return this->client_->send_climate_state(climate); }
 #endif
+#ifdef USE_NUMBER
+bool InitialStateIterator::on_number(number::Number *number) {
+  return this->client_->send_number_state(number, number->state);
+}
+#endif
+#ifdef USE_SELECT
+bool InitialStateIterator::on_select(select::Select *select) {
+  return this->client_->send_select_state(select, select->state);
+}
+#endif
 InitialStateIterator::InitialStateIterator(APIServer *server, APIConnection *client)
     : ComponentIterator(server), client_(client) {}
 

esphome/components/api/subscribe_state.h

@@ -36,6 +36,12 @@ class InitialStateIterator : public ComponentIterator {
 #endif
 #ifdef USE_CLIMATE
   bool on_climate(climate::Climate *climate) override;
+#endif
+#ifdef USE_NUMBER
+  bool on_number(number::Number *number) override;
+#endif
+#ifdef USE_SELECT
+  bool on_select(select::Select *select) override;
 #endif
  protected:
   APIConnection *client_;

esphome/components/api/user_services.cpp

@@ -15,7 +15,7 @@ template<> std::string get_execute_arg_value<std::string>(const ExecuteServiceAr
 template<> std::vector<bool> get_execute_arg_value<std::vector<bool>>(const ExecuteServiceArgument &arg) {
   return arg.bool_array;
 }
-template<> std::vector<int> get_execute_arg_value<std::vector<int>>(const ExecuteServiceArgument &arg) {
+template<> std::vector<int32_t> get_execute_arg_value<std::vector<int32_t>>(const ExecuteServiceArgument &arg) {
   return arg.int_array;
 }
 template<> std::vector<float> get_execute_arg_value<std::vector<float>>(const ExecuteServiceArgument &arg) {

esphome/components/api/user_services.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"
 #include "api_pb2.h"
@@ -20,8 +22,8 @@ template<typename T> enums::ServiceArgType to_service_arg_type();
 
 template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
  public:
-  UserServiceBase(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names)
-      : name_(name), arg_names_(arg_names) {
+  UserServiceBase(std::string name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+      : name_(std::move(name)), arg_names_(arg_names) {
     this->key_ = fnv1_hash(this->name_);
   }
 

esphome/components/api/util.cpp

@@ -167,6 +167,36 @@ void ComponentIterator::advance() {
         }
       }
       break;
+#endif
+#ifdef USE_NUMBER
+    case IteratorState::NUMBER:
+      if (this->at_ >= App.get_numbers().size()) {
+        advance_platform = true;
+      } else {
+        auto *number = App.get_numbers()[this->at_];
+        if (number->is_internal()) {
+          success = true;
+          break;
+        } else {
+          success = this->on_number(number);
+        }
+      }
+      break;
+#endif
+#ifdef USE_SELECT
+    case IteratorState::SELECT:
+      if (this->at_ >= App.get_selects().size()) {
+        advance_platform = true;
+      } else {
+        auto *select = App.get_selects()[this->at_];
+        if (select->is_internal()) {
+          success = true;
+          break;
+        } else {
+          success = this->on_select(select);
+        }
+      }
+      break;
 #endif
     case IteratorState::MAX:
       if (this->on_end()) {

esphome/components/api/util.h

@@ -47,6 +47,12 @@ class ComponentIterator {
 #endif
 #ifdef USE_CLIMATE
   virtual bool on_climate(climate::Climate *climate) = 0;
+#endif
+#ifdef USE_NUMBER
+  virtual bool on_number(number::Number *number) = 0;
+#endif
+#ifdef USE_SELECT
+  virtual bool on_select(select::Select *select) = 0;
 #endif
   virtual bool on_end();
 
@@ -81,6 +87,12 @@ class ComponentIterator {
 #endif
 #ifdef USE_CLIMATE
     CLIMATE,
+#endif
+#ifdef USE_NUMBER
+    NUMBER,
+#endif
+#ifdef USE_SELECT
+    SELECT,
 #endif
     MAX,
   } state_{IteratorState::NONE};

esphome/components/as3935/__init__.py

@@ -1,40 +1,48 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.const import CONF_INDOOR, CONF_WATCHDOG_THRESHOLD, \
-    CONF_NOISE_LEVEL, CONF_SPIKE_REJECTION, CONF_LIGHTNING_THRESHOLD, \
-    CONF_MASK_DISTURBER, CONF_DIV_RATIO, CONF_CAPACITANCE
-from esphome.core import coroutine
+from esphome.const import (
+    CONF_INDOOR,
+    CONF_WATCHDOG_THRESHOLD,
+    CONF_NOISE_LEVEL,
+    CONF_SPIKE_REJECTION,
+    CONF_LIGHTNING_THRESHOLD,
+    CONF_MASK_DISTURBER,
+    CONF_DIV_RATIO,
+    CONF_CAPACITANCE,
+)
 
-AUTO_LOAD = ['sensor', 'binary_sensor']
+AUTO_LOAD = ["sensor", "binary_sensor"]
 MULTI_CONF = True
 
-CONF_AS3935_ID = 'as3935_id'
+CONF_AS3935_ID = "as3935_id"
 
-as3935_ns = cg.esphome_ns.namespace('as3935')
-AS3935 = as3935_ns.class_('AS3935Component', cg.Component)
+as3935_ns = cg.esphome_ns.namespace("as3935")
+AS3935 = as3935_ns.class_("AS3935Component", cg.Component)
 
-CONF_IRQ_PIN = 'irq_pin'
-AS3935_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(AS3935),
-    cv.Required(CONF_IRQ_PIN): pins.gpio_input_pin_schema,
-
-    cv.Optional(CONF_INDOOR, default=True): cv.boolean,
-    cv.Optional(CONF_NOISE_LEVEL, default=2): cv.int_range(min=1, max=7),
-    cv.Optional(CONF_WATCHDOG_THRESHOLD, default=2): cv.int_range(min=1, max=10),
-    cv.Optional(CONF_SPIKE_REJECTION, default=2): cv.int_range(min=1, max=11),
-    cv.Optional(CONF_LIGHTNING_THRESHOLD, default=1): cv.one_of(1, 5, 9, 16, int=True),
-    cv.Optional(CONF_MASK_DISTURBER, default=False): cv.boolean,
-    cv.Optional(CONF_DIV_RATIO, default=0): cv.one_of(0, 16, 32, 64, 128, int=True),
-    cv.Optional(CONF_CAPACITANCE, default=0): cv.int_range(min=0, max=15),
-})
+CONF_IRQ_PIN = "irq_pin"
+AS3935_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(AS3935),
+        cv.Required(CONF_IRQ_PIN): pins.gpio_input_pin_schema,
+        cv.Optional(CONF_INDOOR, default=True): cv.boolean,
+        cv.Optional(CONF_NOISE_LEVEL, default=2): cv.int_range(min=1, max=7),
+        cv.Optional(CONF_WATCHDOG_THRESHOLD, default=2): cv.int_range(min=1, max=10),
+        cv.Optional(CONF_SPIKE_REJECTION, default=2): cv.int_range(min=1, max=11),
+        cv.Optional(CONF_LIGHTNING_THRESHOLD, default=1): cv.one_of(
+            1, 5, 9, 16, int=True
+        ),
+        cv.Optional(CONF_MASK_DISTURBER, default=False): cv.boolean,
+        cv.Optional(CONF_DIV_RATIO, default=0): cv.one_of(0, 16, 32, 64, 128, int=True),
+        cv.Optional(CONF_CAPACITANCE, default=0): cv.int_range(min=0, max=15),
+    }
+)
 
 
-@coroutine
-def setup_as3935(var, config):
-    yield cg.register_component(var, config)
+async def setup_as3935(var, config):
+    await cg.register_component(var, config)
 
-    irq_pin = yield cg.gpio_pin_expression(config[CONF_IRQ_PIN])
+    irq_pin = await cg.gpio_pin_expression(config[CONF_IRQ_PIN])
     cg.add(var.set_irq_pin(irq_pin))
     cg.add(var.set_indoor(config[CONF_INDOOR]))
     cg.add(var.set_noise_level(config[CONF_NOISE_LEVEL]))

esphome/components/as3935/as3935.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace as3935 {
 
-static const char *TAG = "as3935";
+static const char *const TAG = "as3935";
 
 void AS3935Component::setup() {
   ESP_LOGCONFIG(TAG, "Setting up AS3935...");

esphome/components/as3935/binary_sensor.py

@@ -3,14 +3,16 @@ import esphome.config_validation as cv
 from esphome.components import binary_sensor
 from . import AS3935, CONF_AS3935_ID
 
-DEPENDENCIES = ['as3935']
+DEPENDENCIES = ["as3935"]
 
-CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
-})
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
+    }
+)
 
 
-def to_code(config):
-    hub = yield cg.get_variable(config[CONF_AS3935_ID])
-    var = yield binary_sensor.new_binary_sensor(config)
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_AS3935_ID])
+    var = await binary_sensor.new_binary_sensor(config)
     cg.add(hub.set_thunder_alert_binary_sensor(var))

esphome/components/as3935/sensor.py

@@ -1,30 +1,45 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor
-from esphome.const import CONF_DISTANCE, CONF_LIGHTNING_ENERGY, \
-    UNIT_KILOMETER, UNIT_EMPTY, ICON_SIGNAL_DISTANCE_VARIANT, ICON_FLASH
+from esphome.const import (
+    CONF_DISTANCE,
+    CONF_LIGHTNING_ENERGY,
+    STATE_CLASS_NONE,
+    UNIT_KILOMETER,
+    ICON_SIGNAL_DISTANCE_VARIANT,
+    ICON_FLASH,
+)
 from . import AS3935, CONF_AS3935_ID
 
-DEPENDENCIES = ['as3935']
+DEPENDENCIES = ["as3935"]
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
-    cv.Optional(CONF_DISTANCE):
-        sensor.sensor_schema(UNIT_KILOMETER, ICON_SIGNAL_DISTANCE_VARIANT, 1),
-    cv.Optional(CONF_LIGHTNING_ENERGY):
-        sensor.sensor_schema(UNIT_EMPTY, ICON_FLASH, 1),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
+        cv.Optional(CONF_DISTANCE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_KILOMETER,
+            icon=ICON_SIGNAL_DISTANCE_VARIANT,
+            accuracy_decimals=1,
+            state_class=STATE_CLASS_NONE,
+        ),
+        cv.Optional(CONF_LIGHTNING_ENERGY): sensor.sensor_schema(
+            icon=ICON_FLASH,
+            accuracy_decimals=1,
+            state_class=STATE_CLASS_NONE,
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
-def to_code(config):
-    hub = yield cg.get_variable(config[CONF_AS3935_ID])
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_AS3935_ID])
 
     if CONF_DISTANCE in config:
         conf = config[CONF_DISTANCE]
-        distance_sensor = yield sensor.new_sensor(conf)
+        distance_sensor = await sensor.new_sensor(conf)
         cg.add(hub.set_distance_sensor(distance_sensor))
 
     if CONF_LIGHTNING_ENERGY in config:
         conf = config[CONF_LIGHTNING_ENERGY]
-        lightning_energy_sensor = yield sensor.new_sensor(conf)
+        lightning_energy_sensor = await sensor.new_sensor(conf)
         cg.add(hub.set_energy_sensor(lightning_energy_sensor))

esphome/components/as3935_i2c/__init__.py

@@ -3,18 +3,24 @@ import esphome.config_validation as cv
 from esphome.components import as3935, i2c
 from esphome.const import CONF_ID
 
-AUTO_LOAD = ['as3935']
-DEPENDENCIES = ['i2c']
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["i2c"]
 
-as3935_i2c_ns = cg.esphome_ns.namespace('as3935_i2c')
-I2CAS3935 = as3935_i2c_ns.class_('I2CAS3935Component', as3935.AS3935, i2c.I2CDevice)
+as3935_i2c_ns = cg.esphome_ns.namespace("as3935_i2c")
+I2CAS3935 = as3935_i2c_ns.class_("I2CAS3935Component", as3935.AS3935, i2c.I2CDevice)
 
-CONFIG_SCHEMA = cv.All(as3935.AS3935_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(I2CAS3935),
-}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x03)))
+CONFIG_SCHEMA = cv.All(
+    as3935.AS3935_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(I2CAS3935),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x03))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield as3935.setup_as3935(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await as3935.setup_as3935(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/as3935_i2c/as3935_i2c.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace as3935_i2c {
 
-static const char *TAG = "as3935_i2c";
+static const char *const TAG = "as3935_i2c";
 
 void I2CAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_pos) {
   uint8_t write_reg;

esphome/components/as3935_spi/__init__.py

@@ -3,18 +3,24 @@ import esphome.config_validation as cv
 from esphome.components import as3935, spi
 from esphome.const import CONF_ID
 
-AUTO_LOAD = ['as3935']
-DEPENDENCIES = ['spi']
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["spi"]
 
-as3935_spi_ns = cg.esphome_ns.namespace('as3935_spi')
-SPIAS3935 = as3935_spi_ns.class_('SPIAS3935Component', as3935.AS3935, spi.SPIDevice)
+as3935_spi_ns = cg.esphome_ns.namespace("as3935_spi")
+SPIAS3935 = as3935_spi_ns.class_("SPIAS3935Component", as3935.AS3935, spi.SPIDevice)
 
-CONFIG_SCHEMA = cv.All(as3935.AS3935_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(SPIAS3935),
-}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema(cs_pin_required=True)))
+CONFIG_SCHEMA = cv.All(
+    as3935.AS3935_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(SPIAS3935),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(spi.spi_device_schema(cs_pin_required=True))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield as3935.setup_as3935(var, config)
-    yield spi.register_spi_device(var, config)
+    await as3935.setup_as3935(var, config)
+    await spi.register_spi_device(var, config)

esphome/components/as3935_spi/as3935_spi.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace as3935_spi {
 
-static const char *TAG = "as3935_spi";
+static const char *const TAG = "as3935_spi";
 
 void SPIAS3935Component::setup() {
   ESP_LOGI(TAG, "SPIAS3935Component setup started!");
@@ -33,7 +33,7 @@ void SPIAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits,
 uint8_t SPIAS3935Component::read_register(uint8_t reg) {
   uint8_t value = 0;
   this->enable();
-  this->write_byte(reg |= SPI_READ_M);
+  this->write_byte(reg | SPI_READ_M);
   value = this->read_byte();
   // According to datsheet, the chip select must be written HIGH, LOW, HIGH
   // to correctly end the READ command.

esphome/components/async_tcp/__init__.py

@@ -2,14 +2,14 @@
 import esphome.codegen as cg
 from esphome.core import CORE, coroutine_with_priority
 
-CODEOWNERS = ['@OttoWinter']
+CODEOWNERS = ["@OttoWinter"]
 
 
 @coroutine_with_priority(200.0)
-def to_code(config):
+async def to_code(config):
     if CORE.is_esp32:
-        # https://github.com/OttoWinter/AsyncTCP/blob/master/library.json
-        cg.add_library('AsyncTCP-esphome', '1.1.1')
+        # https://github.com/esphome/AsyncTCP/blob/master/library.json
+        cg.add_library("esphome/AsyncTCP-esphome", "1.2.2")
     elif CORE.is_esp8266:
         # https://github.com/OttoWinter/ESPAsyncTCP
-        cg.add_library('ESPAsyncTCP-esphome', '1.2.3')
+        cg.add_library("ESPAsyncTCP-esphome", "1.2.3")

esphome/components/atc_mithermometer/atc_mithermometer.cpp

@@ -0,0 +1,137 @@
+#include "atc_mithermometer.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace atc_mithermometer {
+
+static const char *const TAG = "atc_mithermometer";
+
+void ATCMiThermometer::dump_config() {
+  ESP_LOGCONFIG(TAG, "ATC MiThermometer");
+  LOG_SENSOR("  ", "Temperature", this->temperature_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_);
+  LOG_SENSOR("  ", "Battery Level", this->battery_level_);
+  LOG_SENSOR("  ", "Battery Voltage", this->battery_voltage_);
+}
+
+bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  if (device.address_uint64() != this->address_) {
+    ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
+    return false;
+  }
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
+
+  bool success = false;
+  for (auto &service_data : device.get_service_datas()) {
+    auto res = parse_header(service_data);
+    if (res->is_duplicate) {
+      continue;
+    }
+    if (!(parse_message(service_data.data, *res))) {
+      continue;
+    }
+    if (!(report_results(res, device.address_str()))) {
+      continue;
+    }
+    if (res->temperature.has_value() && this->temperature_ != nullptr)
+      this->temperature_->publish_state(*res->temperature);
+    if (res->humidity.has_value() && this->humidity_ != nullptr)
+      this->humidity_->publish_state(*res->humidity);
+    if (res->battery_level.has_value() && this->battery_level_ != nullptr)
+      this->battery_level_->publish_state(*res->battery_level);
+    if (res->battery_voltage.has_value() && this->battery_voltage_ != nullptr)
+      this->battery_voltage_->publish_state(*res->battery_voltage);
+    success = true;
+  }
+
+  if (!success) {
+    return false;
+  }
+
+  return true;
+}
+
+optional<ParseResult> ATCMiThermometer::parse_header(const esp32_ble_tracker::ServiceData &service_data) {
+  ParseResult result;
+  if (!service_data.uuid.contains(0x1A, 0x18)) {
+    ESP_LOGVV(TAG, "parse_header(): no service data UUID magic bytes.");
+    return {};
+  }
+
+  auto raw = service_data.data;
+
+  static uint8_t last_frame_count = 0;
+  if (last_frame_count == raw[12]) {
+    ESP_LOGVV(TAG, "parse_header(): duplicate data packet received (%d).", static_cast<int>(last_frame_count));
+    result.is_duplicate = true;
+    return {};
+  }
+  last_frame_count = raw[12];
+  result.is_duplicate = false;
+
+  return result;
+}
+
+bool ATCMiThermometer::parse_message(const std::vector<uint8_t> &message, ParseResult &result) {
+  // Byte 0-5 mac in correct order
+  // Byte 6-7 Temperature in uint16
+  // Byte 8 Humidity in percent
+  // Byte 9 Battery in percent
+  // Byte 10-11 Battery in mV uint16_t
+  // Byte 12 frame packet counter
+
+  const uint8_t *data = message.data();
+  const int data_length = 13;
+
+  if (message.size() != data_length) {
+    ESP_LOGVV(TAG, "parse_message(): payload has wrong size (%d)!", message.size());
+    return false;
+  }
+
+  // temperature, 2 bytes, 16-bit signed integer (LE), 0.1 °C
+  const int16_t temperature = uint16_t(data[7]) | (uint16_t(data[6]) << 8);
+  result.temperature = temperature / 10.0f;
+
+  // humidity, 1 byte, 8-bit unsigned integer, 1.0 %
+  result.humidity = data[8];
+
+  // battery, 1 byte, 8-bit unsigned integer,  1.0 %
+  result.battery_level = data[9];
+
+  // battery, 2 bytes, 16-bit unsigned integer,  0.001 V
+  const int16_t battery_voltage = uint16_t(data[11]) | (uint16_t(data[10]) << 8);
+  result.battery_voltage = battery_voltage / 1.0e3f;
+
+  return true;
+}
+
+bool ATCMiThermometer::report_results(const optional<ParseResult> &result, const std::string &address) {
+  if (!result.has_value()) {
+    ESP_LOGVV(TAG, "report_results(): no results available.");
+    return false;
+  }
+
+  ESP_LOGD(TAG, "Got ATC MiThermometer (%s):", address.c_str());
+
+  if (result->temperature.has_value()) {
+    ESP_LOGD(TAG, "  Temperature: %.1f °C", *result->temperature);
+  }
+  if (result->humidity.has_value()) {
+    ESP_LOGD(TAG, "  Humidity: %.0f %%", *result->humidity);
+  }
+  if (result->battery_level.has_value()) {
+    ESP_LOGD(TAG, "  Battery Level: %.0f %%", *result->battery_level);
+  }
+  if (result->battery_voltage.has_value()) {
+    ESP_LOGD(TAG, "  Battery Voltage: %.3f V", *result->battery_voltage);
+  }
+
+  return true;
+}
+
+}  // namespace atc_mithermometer
+}  // namespace esphome
+
+#endif

esphome/components/atc_mithermometer/atc_mithermometer.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace atc_mithermometer {
+
+struct ParseResult {
+  optional<float> temperature;
+  optional<float> humidity;
+  optional<float> battery_level;
+  optional<float> battery_voltage;
+  bool is_duplicate;
+  int raw_offset;
+};
+
+class ATCMiThermometer : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
+ public:
+  void set_address(uint64_t address) { address_ = address; };
+
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
+  void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
+  void set_battery_level(sensor::Sensor *battery_level) { battery_level_ = battery_level; }
+  void set_battery_voltage(sensor::Sensor *battery_voltage) { battery_voltage_ = battery_voltage; }
+
+ protected:
+  uint64_t address_;
+  sensor::Sensor *temperature_{nullptr};
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *battery_level_{nullptr};
+  sensor::Sensor *battery_voltage_{nullptr};
+
+  optional<ParseResult> parse_header(const esp32_ble_tracker::ServiceData &service_data);
+  bool parse_message(const std::vector<uint8_t> &message, ParseResult &result);
+  bool report_results(const optional<ParseResult> &result, const std::string &address);
+};
+
+}  // namespace atc_mithermometer
+}  // namespace esphome
+
+#endif

esphome/components/atc_mithermometer/sensor.py

@@ -0,0 +1,84 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, esp32_ble_tracker
+from esphome.const import (
+    CONF_BATTERY_LEVEL,
+    CONF_BATTERY_VOLTAGE,
+    CONF_MAC_ADDRESS,
+    CONF_HUMIDITY,
+    CONF_TEMPERATURE,
+    CONF_ID,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+CODEOWNERS = ["@ahpohl"]
+
+DEPENDENCIES = ["esp32_ble_tracker"]
+
+atc_mithermometer_ns = cg.esphome_ns.namespace("atc_mithermometer")
+ATCMiThermometer = atc_mithermometer_ns.class_(
+    "ATCMiThermometer", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ATCMiThermometer),
+            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_BATTERY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+
+    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))
+    if CONF_BATTERY_LEVEL in config:
+        sens = await sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery_level(sens))
+    if CONF_BATTERY_VOLTAGE in config:
+        sens = await sensor.new_sensor(config[CONF_BATTERY_VOLTAGE])
+        cg.add(var.set_battery_voltage(sens))

esphome/components/atm90e32/atm90e32.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace atm90e32 {
 
-static const char *TAG = "atm90e32";
+static const char *const TAG = "atm90e32";
 
 void ATM90E32Component::update() {
   if (this->read16_(ATM90E32_REGISTER_METEREN) != 1) {
@@ -58,6 +58,24 @@ void ATM90E32Component::update() {
   if (this->phase_[2].power_factor_sensor_ != nullptr) {
     this->phase_[2].power_factor_sensor_->publish_state(this->get_power_factor_c_());
   }
+  if (this->phase_[0].forward_active_energy_sensor_ != nullptr) {
+    this->phase_[0].forward_active_energy_sensor_->publish_state(this->get_forward_active_energy_a_());
+  }
+  if (this->phase_[1].forward_active_energy_sensor_ != nullptr) {
+    this->phase_[1].forward_active_energy_sensor_->publish_state(this->get_forward_active_energy_b_());
+  }
+  if (this->phase_[2].forward_active_energy_sensor_ != nullptr) {
+    this->phase_[2].forward_active_energy_sensor_->publish_state(this->get_forward_active_energy_c_());
+  }
+  if (this->phase_[0].reverse_active_energy_sensor_ != nullptr) {
+    this->phase_[0].reverse_active_energy_sensor_->publish_state(this->get_reverse_active_energy_a_());
+  }
+  if (this->phase_[1].reverse_active_energy_sensor_ != nullptr) {
+    this->phase_[1].reverse_active_energy_sensor_->publish_state(this->get_reverse_active_energy_b_());
+  }
+  if (this->phase_[2].reverse_active_energy_sensor_ != nullptr) {
+    this->phase_[2].reverse_active_energy_sensor_->publish_state(this->get_reverse_active_energy_c_());
+  }
   if (this->freq_sensor_ != nullptr) {
     this->freq_sensor_->publish_state(this->get_frequency_());
   }
@@ -119,16 +137,22 @@ void ATM90E32Component::dump_config() {
   LOG_SENSOR("  ", "Power A", this->phase_[0].power_sensor_);
   LOG_SENSOR("  ", "Reactive Power A", this->phase_[0].reactive_power_sensor_);
   LOG_SENSOR("  ", "PF A", this->phase_[0].power_factor_sensor_);
+  LOG_SENSOR("  ", "Active Forward Energy A", this->phase_[0].forward_active_energy_sensor_);
+  LOG_SENSOR("  ", "Active Reverse Energy A", this->phase_[0].reverse_active_energy_sensor_);
   LOG_SENSOR("  ", "Voltage B", this->phase_[1].voltage_sensor_);
   LOG_SENSOR("  ", "Current B", this->phase_[1].current_sensor_);
   LOG_SENSOR("  ", "Power B", this->phase_[1].power_sensor_);
   LOG_SENSOR("  ", "Reactive Power B", this->phase_[1].reactive_power_sensor_);
   LOG_SENSOR("  ", "PF B", this->phase_[1].power_factor_sensor_);
+  LOG_SENSOR("  ", "Active Forward Energy B", this->phase_[1].forward_active_energy_sensor_);
+  LOG_SENSOR("  ", "Active Reverse Energy B", this->phase_[1].reverse_active_energy_sensor_);
   LOG_SENSOR("  ", "Voltage C", this->phase_[2].voltage_sensor_);
   LOG_SENSOR("  ", "Current C", this->phase_[2].current_sensor_);
   LOG_SENSOR("  ", "Power C", this->phase_[2].power_sensor_);
   LOG_SENSOR("  ", "Reactive Power C", this->phase_[2].reactive_power_sensor_);
   LOG_SENSOR("  ", "PF C", this->phase_[2].power_factor_sensor_);
+  LOG_SENSOR("  ", "Active Forward Energy C", this->phase_[2].forward_active_energy_sensor_);
+  LOG_SENSOR("  ", "Active Reverse Energy C", this->phase_[2].reverse_active_energy_sensor_);
   LOG_SENSOR("  ", "Frequency", this->freq_sensor_);
   LOG_SENSOR("  ", "Chip Temp", this->chip_temperature_sensor_);
 }
@@ -239,6 +263,30 @@ float ATM90E32Component::get_power_factor_c_() {
   int16_t pf = this->read16_(ATM90E32_REGISTER_PFMEANC);
   return (float) pf / 1000;
 }
+float ATM90E32Component::get_forward_active_energy_a_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYA);
+  return (float) val * 10 / 3200;  // convert register value to WattHours
+}
+float ATM90E32Component::get_forward_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYB);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_forward_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYC);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_a_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYA);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYB);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYC);
+  return (float) val * 10 / 3200;
+}
 float ATM90E32Component::get_frequency_() {
   uint16_t freq = this->read16_(ATM90E32_REGISTER_FREQ);
   return (float) freq / 100;

esphome/components/atm90e32/atm90e32.h

@@ -20,6 +20,12 @@ class ATM90E32Component : public PollingComponent,
   void set_current_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].current_sensor_ = obj; }
   void set_power_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].power_sensor_ = obj; }
   void set_reactive_power_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].reactive_power_sensor_ = obj; }
+  void set_forward_active_energy_sensor(int phase, sensor::Sensor *obj) {
+    this->phase_[phase].forward_active_energy_sensor_ = obj;
+  }
+  void set_reverse_active_energy_sensor(int phase, sensor::Sensor *obj) {
+    this->phase_[phase].reverse_active_energy_sensor_ = obj;
+  }
   void set_power_factor_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].power_factor_sensor_ = obj; }
   void set_volt_gain(int phase, uint16_t gain) { this->phase_[phase].volt_gain_ = gain; }
   void set_ct_gain(int phase, uint16_t gain) { this->phase_[phase].ct_gain_ = gain; }
@@ -52,6 +58,12 @@ class ATM90E32Component : public PollingComponent,
   float get_power_factor_a_();
   float get_power_factor_b_();
   float get_power_factor_c_();
+  float get_forward_active_energy_a_();
+  float get_forward_active_energy_b_();
+  float get_forward_active_energy_c_();
+  float get_reverse_active_energy_a_();
+  float get_reverse_active_energy_b_();
+  float get_reverse_active_energy_c_();
   float get_frequency_();
   float get_chip_temperature_();
 
@@ -63,6 +75,8 @@ class ATM90E32Component : public PollingComponent,
     sensor::Sensor *power_sensor_{nullptr};
     sensor::Sensor *reactive_power_sensor_{nullptr};
     sensor::Sensor *power_factor_sensor_{nullptr};
+    sensor::Sensor *forward_active_energy_sensor_{nullptr};
+    sensor::Sensor *reverse_active_energy_sensor_{nullptr};
   } phase_[3];
   sensor::Sensor *freq_sensor_{nullptr};
   sensor::Sensor *chip_temperature_sensor_{nullptr};

esphome/components/atm90e32/atm90e32_reg.h

@@ -39,7 +39,7 @@ static const uint16_t ATM90E32_STATUS_S0_OVPHASEBST = 1 << 11;  // Over voltage
 static const uint16_t ATM90E32_STATUS_S0_OVPHASECST = 1 << 10;  // Over voltage on phase C
 static const uint16_t ATM90E32_STATUS_S0_UREVWNST = 1 << 9;     // Voltage Phase Sequence Error status
 static const uint16_t ATM90E32_STATUS_S0_IREVWNST = 1 << 8;     // Current Phase Sequence Error status
-static const uint16_t ATM90E32_STATUS_S0_INOV0ST = 1 << 7;      // Calculated N line current greater tha INWarnTh reg
+static const uint16_t ATM90E32_STATUS_S0_INOV0ST = 1 << 7;      // Calculated N line current greater than INWarnTh reg
 static const uint16_t ATM90E32_STATUS_S0_TQNOLOADST = 1 << 6;   // All phase sum reactive power no-load condition status
 static const uint16_t ATM90E32_STATUS_S0_TPNOLOADST = 1 << 5;   // All phase sum active power no-load condition status
 static const uint16_t ATM90E32_STATUS_S0_TASNOLOADST = 1 << 4;  // All phase sum apparent power no-load status

esphome/components/atm90e32/sensor.py

@@ -1,67 +1,149 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, spi
-from esphome.const import \
-    CONF_ID, CONF_VOLTAGE, CONF_CURRENT, CONF_POWER, CONF_POWER_FACTOR, CONF_FREQUENCY, \
-    ICON_FLASH, ICON_LIGHTBULB, ICON_CURRENT_AC, ICON_THERMOMETER, \
-    UNIT_HERTZ, UNIT_VOLT, UNIT_AMPERE, UNIT_WATT, UNIT_EMPTY, UNIT_CELSIUS, UNIT_VOLT_AMPS_REACTIVE
+from esphome.const import (
+    CONF_ID,
+    CONF_REACTIVE_POWER,
+    CONF_VOLTAGE,
+    CONF_CURRENT,
+    CONF_POWER,
+    CONF_POWER_FACTOR,
+    CONF_FREQUENCY,
+    CONF_FORWARD_ACTIVE_ENERGY,
+    CONF_REVERSE_ACTIVE_ENERGY,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_LIGHTBULB,
+    ICON_CURRENT_AC,
+    LAST_RESET_TYPE_AUTO,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_HERTZ,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+    UNIT_CELSIUS,
+    UNIT_VOLT_AMPS_REACTIVE,
+    UNIT_WATT_HOURS,
+)
 
-CONF_PHASE_A = 'phase_a'
-CONF_PHASE_B = 'phase_b'
-CONF_PHASE_C = 'phase_c'
+CONF_PHASE_A = "phase_a"
+CONF_PHASE_B = "phase_b"
+CONF_PHASE_C = "phase_c"
 
-CONF_REACTIVE_POWER = 'reactive_power'
-CONF_LINE_FREQUENCY = 'line_frequency'
-CONF_CHIP_TEMPERATURE = 'chip_temperature'
-CONF_GAIN_PGA = 'gain_pga'
-CONF_CURRENT_PHASES = 'current_phases'
-CONF_GAIN_VOLTAGE = 'gain_voltage'
-CONF_GAIN_CT = 'gain_ct'
+CONF_LINE_FREQUENCY = "line_frequency"
+CONF_CHIP_TEMPERATURE = "chip_temperature"
+CONF_GAIN_PGA = "gain_pga"
+CONF_CURRENT_PHASES = "current_phases"
+CONF_GAIN_VOLTAGE = "gain_voltage"
+CONF_GAIN_CT = "gain_ct"
 LINE_FREQS = {
-    '50HZ': 50,
-    '60HZ': 60,
+    "50HZ": 50,
+    "60HZ": 60,
 }
 CURRENT_PHASES = {
-    '2': 2,
-    '3': 3,
+    "2": 2,
+    "3": 3,
 }
 PGA_GAINS = {
-    '1X': 0x0,
-    '2X': 0x15,
-    '4X': 0x2A,
+    "1X": 0x0,
+    "2X": 0x15,
+    "4X": 0x2A,
 }
 
-atm90e32_ns = cg.esphome_ns.namespace('atm90e32')
-ATM90E32Component = atm90e32_ns.class_('ATM90E32Component', cg.PollingComponent, spi.SPIDevice)
+atm90e32_ns = cg.esphome_ns.namespace("atm90e32")
+ATM90E32Component = atm90e32_ns.class_(
+    "ATM90E32Component", cg.PollingComponent, spi.SPIDevice
+)
 
-ATM90E32_PHASE_SCHEMA = cv.Schema({
-    cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
-    cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_CURRENT_AC, 2),
-    cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2),
-    cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(UNIT_VOLT_AMPS_REACTIVE,
-                                                           ICON_LIGHTBULB, 2),
-    cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(UNIT_EMPTY, ICON_FLASH, 2),
-    cv.Optional(CONF_GAIN_VOLTAGE, default=7305): cv.uint16_t,
-    cv.Optional(CONF_GAIN_CT, default=27961): cv.uint16_t,
-})
+ATM90E32_PHASE_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_CURRENT): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_POWER): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT_AMPS_REACTIVE,
+            icon=ICON_LIGHTBULB,
+            accuracy_decimals=2,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_POWER_FACTOR,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_FORWARD_ACTIVE_ENERGY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_MEASUREMENT,
+            last_reset_type=LAST_RESET_TYPE_AUTO,
+        ),
+        cv.Optional(CONF_REVERSE_ACTIVE_ENERGY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_MEASUREMENT,
+            last_reset_type=LAST_RESET_TYPE_AUTO,
+        ),
+        cv.Optional(CONF_GAIN_VOLTAGE, default=7305): cv.uint16_t,
+        cv.Optional(CONF_GAIN_CT, default=27961): cv.uint16_t,
+    }
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ATM90E32Component),
-    cv.Optional(CONF_PHASE_A): ATM90E32_PHASE_SCHEMA,
-    cv.Optional(CONF_PHASE_B): ATM90E32_PHASE_SCHEMA,
-    cv.Optional(CONF_PHASE_C): ATM90E32_PHASE_SCHEMA,
-    cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(UNIT_HERTZ, ICON_CURRENT_AC, 1),
-    cv.Optional(CONF_CHIP_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
-    cv.Required(CONF_LINE_FREQUENCY): cv.enum(LINE_FREQS, upper=True),
-    cv.Optional(CONF_CURRENT_PHASES, default='3'): cv.enum(CURRENT_PHASES, upper=True),
-    cv.Optional(CONF_GAIN_PGA, default='2X'): cv.enum(PGA_GAINS, upper=True),
-}).extend(cv.polling_component_schema('60s')).extend(spi.spi_device_schema())
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ATM90E32Component),
+            cv.Optional(CONF_PHASE_A): ATM90E32_PHASE_SCHEMA,
+            cv.Optional(CONF_PHASE_B): ATM90E32_PHASE_SCHEMA,
+            cv.Optional(CONF_PHASE_C): ATM90E32_PHASE_SCHEMA,
+            cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HERTZ,
+                icon=ICON_CURRENT_AC,
+                accuracy_decimals=1,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CHIP_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Required(CONF_LINE_FREQUENCY): cv.enum(LINE_FREQS, upper=True),
+            cv.Optional(CONF_CURRENT_PHASES, default="3"): cv.enum(
+                CURRENT_PHASES, upper=True
+            ),
+            cv.Optional(CONF_GAIN_PGA, default="2X"): cv.enum(PGA_GAINS, upper=True),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(spi.spi_device_schema())
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield spi.register_spi_device(var, config)
+    await cg.register_component(var, config)
+    await spi.register_spi_device(var, config)
 
     for i, phase in enumerate([CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]):
         if phase not in config:
@@ -70,25 +152,31 @@ def to_code(config):
         cg.add(var.set_volt_gain(i, conf[CONF_GAIN_VOLTAGE]))
         cg.add(var.set_ct_gain(i, conf[CONF_GAIN_CT]))
         if CONF_VOLTAGE in conf:
-            sens = yield sensor.new_sensor(conf[CONF_VOLTAGE])
+            sens = await sensor.new_sensor(conf[CONF_VOLTAGE])
             cg.add(var.set_voltage_sensor(i, sens))
         if CONF_CURRENT in conf:
-            sens = yield sensor.new_sensor(conf[CONF_CURRENT])
+            sens = await sensor.new_sensor(conf[CONF_CURRENT])
             cg.add(var.set_current_sensor(i, sens))
         if CONF_POWER in conf:
-            sens = yield sensor.new_sensor(conf[CONF_POWER])
+            sens = await sensor.new_sensor(conf[CONF_POWER])
             cg.add(var.set_power_sensor(i, sens))
         if CONF_REACTIVE_POWER in conf:
-            sens = yield sensor.new_sensor(conf[CONF_REACTIVE_POWER])
+            sens = await sensor.new_sensor(conf[CONF_REACTIVE_POWER])
             cg.add(var.set_reactive_power_sensor(i, sens))
         if CONF_POWER_FACTOR in conf:
-            sens = yield sensor.new_sensor(conf[CONF_POWER_FACTOR])
+            sens = await sensor.new_sensor(conf[CONF_POWER_FACTOR])
             cg.add(var.set_power_factor_sensor(i, sens))
+        if CONF_FORWARD_ACTIVE_ENERGY in conf:
+            sens = await sensor.new_sensor(conf[CONF_FORWARD_ACTIVE_ENERGY])
+            cg.add(var.set_forward_active_energy_sensor(i, sens))
+        if CONF_REVERSE_ACTIVE_ENERGY in conf:
+            sens = await sensor.new_sensor(conf[CONF_REVERSE_ACTIVE_ENERGY])
+            cg.add(var.set_reverse_active_energy_sensor(i, sens))
     if CONF_FREQUENCY in config:
-        sens = yield sensor.new_sensor(config[CONF_FREQUENCY])
+        sens = await sensor.new_sensor(config[CONF_FREQUENCY])
         cg.add(var.set_freq_sensor(sens))
     if CONF_CHIP_TEMPERATURE in config:
-        sens = yield sensor.new_sensor(config[CONF_CHIP_TEMPERATURE])
+        sens = await sensor.new_sensor(config[CONF_CHIP_TEMPERATURE])
         cg.add(var.set_chip_temperature_sensor(sens))
     cg.add(var.set_line_freq(config[CONF_LINE_FREQUENCY]))
     cg.add(var.set_current_phases(config[CONF_CURRENT_PHASES]))

esphome/components/b_parasite/b_parasite.cpp

@@ -0,0 +1,82 @@
+#include "b_parasite.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace b_parasite {
+
+static const char *const TAG = "b_parasite";
+
+void BParasite::dump_config() {
+  ESP_LOGCONFIG(TAG, "b_parasite");
+  LOG_SENSOR("  ", "Battery Voltage", this->battery_voltage_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_);
+  LOG_SENSOR("  ", "Soil Moisture", this->soil_moisture_);
+}
+
+bool BParasite::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  if (device.address_uint64() != address_) {
+    ESP_LOGVV(TAG, "parse_device(): unknown MAC address.");
+    return false;
+  }
+  ESP_LOGVV(TAG, "parse_device(): MAC address %s found.", device.address_str().c_str());
+  const auto &service_datas = device.get_service_datas();
+  if (service_datas.size() != 1) {
+    ESP_LOGE(TAG, "Unexpected service_datas size (%d)", service_datas.size());
+    return false;
+  }
+  const auto &service_data = service_datas[0];
+
+  ESP_LOGVV(TAG, "Service data:");
+  for (const uint8_t byte : service_data.data) {
+    ESP_LOGVV(TAG, "0x%02x", byte);
+  }
+
+  const auto &data = service_data.data;
+
+  // Counter for deduplicating messages.
+  uint8_t counter = data[1] & 0x0f;
+  if (last_processed_counter_ == counter) {
+    ESP_LOGVV(TAG, "Skipping already processed counter (%u)", counter);
+    return false;
+  }
+
+  // Battery voltage in millivolts.
+  uint16_t battery_millivolt = data[2] << 8 | data[3];
+  float battery_voltage = battery_millivolt / 1000.0f;
+
+  // Temperature in 1000 * Celsius.
+  uint16_t temp_millicelcius = data[4] << 8 | data[5];
+  float temp_celcius = temp_millicelcius / 1000.0f;
+
+  // Relative air humidity in the range [0, 2^16).
+  uint16_t humidity = data[6] << 8 | data[7];
+  float humidity_percent = (100.0f * humidity) / (1 << 16);
+
+  // Relative soil moisture in [0 - 2^16).
+  uint16_t soil_moisture = data[8] << 8 | data[9];
+  float moisture_percent = (100.0f * soil_moisture) / (1 << 16);
+
+  if (battery_voltage_ != nullptr) {
+    battery_voltage_->publish_state(battery_voltage);
+  }
+  if (temperature_ != nullptr) {
+    temperature_->publish_state(temp_celcius);
+  }
+  if (humidity_ != nullptr) {
+    humidity_->publish_state(humidity_percent);
+  }
+  if (soil_moisture_ != nullptr) {
+    soil_moisture_->publish_state(moisture_percent);
+  }
+
+  last_processed_counter_ = counter;
+  return true;
+}
+
+}  // namespace b_parasite
+}  // namespace esphome
+
+#endif  // ARDUINO_ARCH_ESP32

esphome/components/b_parasite/b_parasite.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace b_parasite {
+
+class BParasite : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
+ public:
+  void set_address(uint64_t address) { address_ = address; };
+  void set_bindkey(const std::string &bindkey);
+
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+  void set_battery_voltage(sensor::Sensor *battery_voltage) { battery_voltage_ = battery_voltage; }
+  void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
+  void set_humidity(sensor::Sensor *humidity) { humidity_ = humidity; }
+  void set_soil_moisture(sensor::Sensor *soil_moisture) { soil_moisture_ = soil_moisture; }
+
+ protected:
+  // The received advertisement packet contains an unsigned 4 bits wrap-around counter
+  // for deduplicating messages.
+  int8_t last_processed_counter_ = -1;
+  uint64_t address_;
+  sensor::Sensor *battery_voltage_{nullptr};
+  sensor::Sensor *temperature_{nullptr};
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *soil_moisture_{nullptr};
+};
+
+}  // namespace b_parasite
+}  // namespace esphome
+
+#endif  // ARDUINO_ARCH_ESP32

esphome/components/b_parasite/sensor.py

@@ -0,0 +1,80 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, esp32_ble_tracker
+from esphome.const import (
+    CONF_BATTERY_VOLTAGE,
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_MOISTURE,
+    CONF_MAC_ADDRESS,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+CODEOWNERS = ["@rbaron"]
+
+DEPENDENCIES = ["esp32_ble_tracker"]
+
+b_parasite_ns = cg.esphome_ns.namespace("b_parasite")
+BParasite = b_parasite_ns.class_(
+    "BParasite", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BParasite),
+            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_MOISTURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+
+    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+
+    for (config_key, setter) in [
+        (CONF_TEMPERATURE, var.set_temperature),
+        (CONF_HUMIDITY, var.set_humidity),
+        (CONF_BATTERY_VOLTAGE, var.set_battery_voltage),
+        (CONF_MOISTURE, var.set_soil_moisture),
+    ]:
+        if config_key in config:
+            sens = await sensor.new_sensor(config[config_key])
+            cg.add(setter(sens))

esphome/components/ballu/ballu.cpp

@@ -0,0 +1,239 @@
+#include "ballu.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace ballu {
+
+static const char *const TAG = "ballu.climate";
+
+const uint16_t BALLU_HEADER_MARK = 9000;
+const uint16_t BALLU_HEADER_SPACE = 4500;
+const uint16_t BALLU_BIT_MARK = 575;
+const uint16_t BALLU_ONE_SPACE = 1675;
+const uint16_t BALLU_ZERO_SPACE = 550;
+
+const uint32_t BALLU_CARRIER_FREQUENCY = 38000;
+
+const uint8_t BALLU_STATE_LENGTH = 13;
+
+const uint8_t BALLU_AUTO = 0;
+const uint8_t BALLU_COOL = 0x20;
+const uint8_t BALLU_DRY = 0x40;
+const uint8_t BALLU_HEAT = 0x80;
+const uint8_t BALLU_FAN = 0xc0;
+
+const uint8_t BALLU_FAN_AUTO = 0xa0;
+const uint8_t BALLU_FAN_HIGH = 0x20;
+const uint8_t BALLU_FAN_MED = 0x40;
+const uint8_t BALLU_FAN_LOW = 0x60;
+
+const uint8_t BALLU_SWING_VER = 0x07;
+const uint8_t BALLU_SWING_HOR = 0xe0;
+const uint8_t BALLU_POWER = 0x20;
+
+void BalluClimate::transmit_state() {
+  uint8_t remote_state[BALLU_STATE_LENGTH] = {0};
+
+  auto temp = (uint8_t) roundf(clamp(this->target_temperature, YKR_K_002E_TEMP_MIN, YKR_K_002E_TEMP_MAX));
+  auto swing_ver =
+      ((this->swing_mode == climate::CLIMATE_SWING_VERTICAL) || (this->swing_mode == climate::CLIMATE_SWING_BOTH));
+  auto swing_hor =
+      ((this->swing_mode == climate::CLIMATE_SWING_HORIZONTAL) || (this->swing_mode == climate::CLIMATE_SWING_BOTH));
+
+  remote_state[0] = 0xc3;
+  remote_state[1] = ((temp - 8) << 3) | (swing_ver ? 0 : BALLU_SWING_VER);
+  remote_state[2] = swing_hor ? 0 : BALLU_SWING_HOR;
+  remote_state[9] = (this->mode == climate::CLIMATE_MODE_OFF) ? 0 : BALLU_POWER;
+  remote_state[11] = 0x1e;
+
+  // Fan speed
+  switch (this->fan_mode.value()) {
+    case climate::CLIMATE_FAN_HIGH:
+      remote_state[4] |= BALLU_FAN_HIGH;
+      break;
+    case climate::CLIMATE_FAN_MEDIUM:
+      remote_state[4] |= BALLU_FAN_MED;
+      break;
+    case climate::CLIMATE_FAN_LOW:
+      remote_state[4] |= BALLU_FAN_LOW;
+      break;
+    case climate::CLIMATE_FAN_AUTO:
+      remote_state[4] |= BALLU_FAN_AUTO;
+      break;
+    default:
+      break;
+  }
+
+  // Mode
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_AUTO:
+      remote_state[6] |= BALLU_AUTO;
+      break;
+    case climate::CLIMATE_MODE_HEAT:
+      remote_state[6] |= BALLU_HEAT;
+      break;
+    case climate::CLIMATE_MODE_COOL:
+      remote_state[6] |= BALLU_COOL;
+      break;
+    case climate::CLIMATE_MODE_DRY:
+      remote_state[6] |= BALLU_DRY;
+      break;
+    case climate::CLIMATE_MODE_FAN_ONLY:
+      remote_state[6] |= BALLU_FAN;
+      break;
+    case climate::CLIMATE_MODE_OFF:
+      remote_state[6] |= BALLU_AUTO;
+    default:
+      break;
+  }
+
+  // Checksum
+  for (uint8_t i = 0; i < BALLU_STATE_LENGTH - 1; i++)
+    remote_state[12] += remote_state[i];
+
+  ESP_LOGV(TAG, "Sending: %02X %02X %02X %02X   %02X %02X %02X %02X   %02X %02X %02X %02X   %02X", remote_state[0],
+           remote_state[1], remote_state[2], remote_state[3], remote_state[4], remote_state[5], remote_state[6],
+           remote_state[7], remote_state[8], remote_state[9], remote_state[10], remote_state[11], remote_state[12]);
+
+  // Send code
+  auto transmit = this->transmitter_->transmit();
+  auto data = transmit.get_data();
+
+  data->set_carrier_frequency(38000);
+
+  // Header
+  data->mark(BALLU_HEADER_MARK);
+  data->space(BALLU_HEADER_SPACE);
+  // Data
+  for (uint8_t i : remote_state) {
+    for (uint8_t j = 0; j < 8; j++) {
+      data->mark(BALLU_BIT_MARK);
+      bool bit = i & (1 << j);
+      data->space(bit ? BALLU_ONE_SPACE : BALLU_ZERO_SPACE);
+    }
+  }
+  // Footer
+  data->mark(BALLU_BIT_MARK);
+
+  transmit.perform();
+}
+
+bool BalluClimate::on_receive(remote_base::RemoteReceiveData data) {
+  // Validate header
+  if (!data.expect_item(BALLU_HEADER_MARK, BALLU_HEADER_SPACE)) {
+    ESP_LOGV(TAG, "Header fail");
+    return false;
+  }
+
+  uint8_t remote_state[BALLU_STATE_LENGTH] = {0};
+  // Read all bytes.
+  for (int i = 0; i < BALLU_STATE_LENGTH; i++) {
+    // Read bit
+    for (int j = 0; j < 8; j++) {
+      if (data.expect_item(BALLU_BIT_MARK, BALLU_ONE_SPACE))
+        remote_state[i] |= 1 << j;
+
+      else if (!data.expect_item(BALLU_BIT_MARK, BALLU_ZERO_SPACE)) {
+        ESP_LOGV(TAG, "Byte %d bit %d fail", i, j);
+        return false;
+      }
+    }
+
+    ESP_LOGVV(TAG, "Byte %d %02X", i, remote_state[i]);
+  }
+  // Validate footer
+  if (!data.expect_mark(BALLU_BIT_MARK)) {
+    ESP_LOGV(TAG, "Footer fail");
+    return false;
+  }
+
+  uint8_t checksum = 0;
+  // Calculate  checksum and compare with signal value.
+  for (uint8_t i = 0; i < BALLU_STATE_LENGTH - 1; i++)
+    checksum += remote_state[i];
+
+  if (checksum != remote_state[BALLU_STATE_LENGTH - 1]) {
+    ESP_LOGVV(TAG, "Checksum fail");
+    return false;
+  }
+
+  ESP_LOGV(TAG, "Received: %02X %02X %02X %02X   %02X %02X %02X %02X   %02X %02X %02X %02X   %02X", remote_state[0],
+           remote_state[1], remote_state[2], remote_state[3], remote_state[4], remote_state[5], remote_state[6],
+           remote_state[7], remote_state[8], remote_state[9], remote_state[10], remote_state[11], remote_state[12]);
+
+  // verify header remote code
+  if (remote_state[0] != 0xc3)
+    return false;
+
+  // powr on/off button
+  ESP_LOGV(TAG, "Power: %02X", (remote_state[9] & BALLU_POWER));
+
+  if ((remote_state[9] & BALLU_POWER) != BALLU_POWER) {
+    this->mode = climate::CLIMATE_MODE_OFF;
+  } else {
+    auto mode = remote_state[6] & 0xe0;
+    ESP_LOGV(TAG, "Mode: %02X", mode);
+    switch (mode) {
+      case BALLU_HEAT:
+        this->mode = climate::CLIMATE_MODE_HEAT;
+        break;
+      case BALLU_COOL:
+        this->mode = climate::CLIMATE_MODE_COOL;
+        break;
+      case BALLU_DRY:
+        this->mode = climate::CLIMATE_MODE_DRY;
+        break;
+      case BALLU_FAN:
+        this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+        break;
+      case BALLU_AUTO:
+        this->mode = climate::CLIMATE_MODE_AUTO;
+        break;
+    }
+  }
+
+  // Set received temp
+  int temp = remote_state[1] & 0xf8;
+  ESP_LOGVV(TAG, "Temperature Raw: %02X", temp);
+  temp = ((uint8_t) temp >> 3) + 8;
+  ESP_LOGVV(TAG, "Temperature Climate: %u", temp);
+  this->target_temperature = temp;
+
+  // Set received fan speed
+  auto fan = remote_state[4] & 0xe0;
+  ESP_LOGVV(TAG, "Fan: %02X", fan);
+  switch (fan) {
+    case BALLU_FAN_HIGH:
+      this->fan_mode = climate::CLIMATE_FAN_HIGH;
+      break;
+    case BALLU_FAN_MED:
+      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      break;
+    case BALLU_FAN_LOW:
+      this->fan_mode = climate::CLIMATE_FAN_LOW;
+      break;
+    case BALLU_FAN_AUTO:
+    default:
+      this->fan_mode = climate::CLIMATE_FAN_AUTO;
+      break;
+  }
+
+  // Set received swing status
+  ESP_LOGVV(TAG, "Swing status: %02X %02X", remote_state[1] & BALLU_SWING_VER, remote_state[2] & BALLU_SWING_HOR);
+  if (((remote_state[1] & BALLU_SWING_VER) != BALLU_SWING_VER) &&
+      ((remote_state[2] & BALLU_SWING_HOR) != BALLU_SWING_HOR)) {
+    this->swing_mode = climate::CLIMATE_SWING_BOTH;
+  } else if ((remote_state[1] & BALLU_SWING_VER) != BALLU_SWING_VER) {
+    this->swing_mode = climate::CLIMATE_SWING_VERTICAL;
+  } else if ((remote_state[2] & BALLU_SWING_HOR) != BALLU_SWING_HOR) {
+    this->swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
+  } else {
+    this->swing_mode = climate::CLIMATE_SWING_OFF;
+  }
+
+  this->publish_state();
+  return true;
+}
+
+}  // namespace ballu
+}  // namespace esphome

esphome/components/ballu/ballu.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "esphome/components/climate_ir/climate_ir.h"
+
+namespace esphome {
+namespace ballu {
+
+// Support for Ballu air conditioners with YKR-K/002E remote
+
+// Temperature
+const float YKR_K_002E_TEMP_MIN = 16.0;
+const float YKR_K_002E_TEMP_MAX = 32.0;
+
+class BalluClimate : public climate_ir::ClimateIR {
+ public:
+  BalluClimate()
+      : climate_ir::ClimateIR(YKR_K_002E_TEMP_MIN, YKR_K_002E_TEMP_MAX, 1.0f, true, true,
+                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                               climate::CLIMATE_FAN_HIGH},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
+                               climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}) {}
+
+ protected:
+  /// Transmit via IR the state of this climate controller.
+  void transmit_state() override;
+  /// Handle received IR Buffer
+  bool on_receive(remote_base::RemoteReceiveData data) override;
+};
+
+}  // namespace ballu
+}  // namespace esphome

esphome/components/ballu/climate.py

@@ -0,0 +1,21 @@
+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"]
+CODEOWNERS = ["@bazuchan"]
+
+ballu_ns = cg.esphome_ns.namespace("ballu")
+BalluClimate = ballu_ns.class_("BalluClimate", climate_ir.ClimateIR)
+
+CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(BalluClimate),
+    }
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await climate_ir.register_climate_ir(var, config)

esphome/components/bang_bang/__init__.py

@@ -1 +1 @@
-CODEOWNERS = ['@OttoWinter']
+CODEOWNERS = ["@OttoWinter"]

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bang_bang {
 
-static const char *TAG = "bang_bang.climate";
+static const char *const TAG = "bang_bang.climate";
 
 void BangBangClimate::setup() {
   this->sensor_->add_on_state_callback([this](float state) {
@@ -21,7 +21,12 @@ void BangBangClimate::setup() {
     restore->to_call(this).perform();
   } else {
     // restore from defaults, change_away handles those for us
-    this->mode = climate::CLIMATE_MODE_AUTO;
+    if (supports_cool_ && supports_heat_)
+      this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+    else if (supports_cool_)
+      this->mode = climate::CLIMATE_MODE_COOL;
+    else if (supports_heat_)
+      this->mode = climate::CLIMATE_MODE_HEAT;
     this->change_away_(false);
   }
 }
@@ -32,8 +37,8 @@ void BangBangClimate::control(const climate::ClimateCall &call) {
     this->target_temperature_low = *call.get_target_temperature_low();
   if (call.get_target_temperature_high().has_value())
     this->target_temperature_high = *call.get_target_temperature_high();
-  if (call.get_away().has_value())
-    this->change_away_(*call.get_away());
+  if (call.get_preset().has_value())
+    this->change_away_(*call.get_preset() == climate::CLIMATE_PRESET_AWAY);
 
   this->compute_state_();
   this->publish_state();
@@ -41,21 +46,27 @@ void BangBangClimate::control(const climate::ClimateCall &call) {
 climate::ClimateTraits BangBangClimate::traits() {
   auto traits = climate::ClimateTraits();
   traits.set_supports_current_temperature(true);
-  traits.set_supports_auto_mode(true);
-  traits.set_supports_cool_mode(this->supports_cool_);
-  traits.set_supports_heat_mode(this->supports_heat_);
+  traits.set_supported_modes({
+      climate::CLIMATE_MODE_OFF,
+  });
+  if (supports_cool_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
+  if (supports_heat_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
+  if (supports_cool_ && supports_heat_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);
   traits.set_supports_two_point_target_temperature(true);
-  traits.set_supports_away(this->supports_away_);
+  if (supports_away_)
+    traits.set_supported_presets({
+        climate::CLIMATE_PRESET_HOME,
+        climate::CLIMATE_PRESET_AWAY,
+    });
   traits.set_supports_action(true);
   return traits;
 }
 void BangBangClimate::compute_state_() {
-  if (this->mode != climate::CLIMATE_MODE_AUTO) {
-    // in non-auto mode, switch directly to appropriate action
-    //  - HEAT mode -> HEATING action
-    //  - COOL mode -> COOLING action
-    //  - OFF mode -> OFF action (not IDLE!)
-    this->switch_to_action_(static_cast<climate::ClimateAction>(this->mode));
+  if (this->mode == climate::CLIMATE_MODE_OFF) {
+    this->switch_to_action_(climate::CLIMATE_ACTION_OFF);
     return;
   }
   if (isnan(this->current_temperature) || isnan(this->target_temperature_low) || isnan(this->target_temperature_high)) {
@@ -140,7 +151,7 @@ void BangBangClimate::change_away_(bool away) {
     this->target_temperature_low = this->away_config_.default_temperature_low;
     this->target_temperature_high = this->away_config_.default_temperature_high;
   }
-  this->away = away;
+  this->preset = away ? climate::CLIMATE_PRESET_AWAY : climate::CLIMATE_PRESET_HOME;
 }
 void BangBangClimate::set_normal_config(const BangBangClimateTargetTempConfig &normal_config) {
   this->normal_config_ = normal_config;

esphome/components/bang_bang/climate.py

@@ -2,56 +2,76 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 from esphome.components import climate, sensor
-from esphome.const import CONF_AWAY_CONFIG, CONF_COOL_ACTION, \
-    CONF_DEFAULT_TARGET_TEMPERATURE_HIGH, CONF_DEFAULT_TARGET_TEMPERATURE_LOW, CONF_HEAT_ACTION, \
-    CONF_ID, CONF_IDLE_ACTION, CONF_SENSOR
+from esphome.const import (
+    CONF_AWAY_CONFIG,
+    CONF_COOL_ACTION,
+    CONF_DEFAULT_TARGET_TEMPERATURE_HIGH,
+    CONF_DEFAULT_TARGET_TEMPERATURE_LOW,
+    CONF_HEAT_ACTION,
+    CONF_ID,
+    CONF_IDLE_ACTION,
+    CONF_SENSOR,
+)
 
-bang_bang_ns = cg.esphome_ns.namespace('bang_bang')
-BangBangClimate = bang_bang_ns.class_('BangBangClimate', climate.Climate, cg.Component)
-BangBangClimateTargetTempConfig = bang_bang_ns.struct('BangBangClimateTargetTempConfig')
+bang_bang_ns = cg.esphome_ns.namespace("bang_bang")
+BangBangClimate = bang_bang_ns.class_("BangBangClimate", climate.Climate, cg.Component)
+BangBangClimateTargetTempConfig = bang_bang_ns.struct("BangBangClimateTargetTempConfig")
 
-CONFIG_SCHEMA = cv.All(climate.CLIMATE_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BangBangClimate),
-    cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
-    cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
-    cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
-    cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
-    cv.Optional(CONF_COOL_ACTION): automation.validate_automation(single=True),
-    cv.Optional(CONF_HEAT_ACTION): automation.validate_automation(single=True),
-    cv.Optional(CONF_AWAY_CONFIG): cv.Schema({
-        cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
-        cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
-    }),
-}).extend(cv.COMPONENT_SCHEMA), cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_HEAT_ACTION))
+CONFIG_SCHEMA = cv.All(
+    climate.CLIMATE_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BangBangClimate),
+            cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
+            cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
+            cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
+            cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_COOL_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_HEAT_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_AWAY_CONFIG): cv.Schema(
+                {
+                    cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_LOW): cv.temperature,
+                    cv.Required(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH): cv.temperature,
+                }
+            ),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_HEAT_ACTION),
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield climate.register_climate(var, config)
+    await cg.register_component(var, config)
+    await climate.register_climate(var, config)
 
-    sens = yield cg.get_variable(config[CONF_SENSOR])
+    sens = await cg.get_variable(config[CONF_SENSOR])
     cg.add(var.set_sensor(sens))
 
     normal_config = BangBangClimateTargetTempConfig(
         config[CONF_DEFAULT_TARGET_TEMPERATURE_LOW],
-        config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]
+        config[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH],
     )
     cg.add(var.set_normal_config(normal_config))
 
-    yield automation.build_automation(var.get_idle_trigger(), [], config[CONF_IDLE_ACTION])
+    await automation.build_automation(
+        var.get_idle_trigger(), [], config[CONF_IDLE_ACTION]
+    )
 
     if CONF_COOL_ACTION in config:
-        yield automation.build_automation(var.get_cool_trigger(), [], config[CONF_COOL_ACTION])
+        await automation.build_automation(
+            var.get_cool_trigger(), [], config[CONF_COOL_ACTION]
+        )
         cg.add(var.set_supports_cool(True))
     if CONF_HEAT_ACTION in config:
-        yield automation.build_automation(var.get_heat_trigger(), [], config[CONF_HEAT_ACTION])
+        await automation.build_automation(
+            var.get_heat_trigger(), [], config[CONF_HEAT_ACTION]
+        )
         cg.add(var.set_supports_heat(True))
 
     if CONF_AWAY_CONFIG in config:
         away = config[CONF_AWAY_CONFIG]
         away_config = BangBangClimateTargetTempConfig(
             away[CONF_DEFAULT_TARGET_TEMPERATURE_LOW],
-            away[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH]
+            away[CONF_DEFAULT_TARGET_TEMPERATURE_HIGH],
         )
         cg.add(var.set_away_config(away_config))

esphome/components/bh1750/bh1750.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bh1750 {
 
-static const char *TAG = "bh1750.sensor";
+static const char *const TAG = "bh1750.sensor";
 
 static const uint8_t BH1750_COMMAND_POWER_ON = 0b00000001;
 static const uint8_t BH1750_COMMAND_MT_REG_HI = 0b01000000;  // last 3 bits
@@ -17,8 +17,8 @@ void BH1750Sensor::setup() {
     return;
   }
 
-  uint8_t mtreg_hi = (this->measurement_time_ >> 5) & 0b111;
-  uint8_t mtreg_lo = (this->measurement_time_ >> 0) & 0b11111;
+  uint8_t mtreg_hi = (this->measurement_duration_ >> 5) & 0b111;
+  uint8_t mtreg_lo = (this->measurement_duration_ >> 0) & 0b11111;
   this->write_bytes(BH1750_COMMAND_MT_REG_HI | mtreg_hi, nullptr, 0);
   this->write_bytes(BH1750_COMMAND_MT_REG_LO | mtreg_lo, nullptr, 0);
 }
@@ -77,7 +77,7 @@ void BH1750Sensor::read_data_() {
   }
 
   float lx = float(raw_value) / 1.2f;
-  lx *= 69.0f / this->measurement_time_;
+  lx *= 69.0f / this->measurement_duration_;
   ESP_LOGD(TAG, "'%s': Got illuminance=%.1flx", this->get_name().c_str(), lx);
   this->publish_state(lx);
   this->status_clear_warning();

esphome/components/bh1750/bh1750.h

@@ -28,7 +28,7 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
    * @param resolution The new resolution of the sensor.
    */
   void set_resolution(BH1750Resolution resolution);
-  void set_measurement_time(uint8_t measurement_time) { measurement_time_ = measurement_time; }
+  void set_measurement_duration(uint8_t measurement_duration) { measurement_duration_ = measurement_duration; }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
@@ -41,7 +41,7 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void read_data_();
 
   BH1750Resolution resolution_{BH1750_RESOLUTION_0P5_LX};
-  uint8_t measurement_time_;
+  uint8_t measurement_duration_;
 };
 
 }  // namespace bh1750

esphome/components/bh1750/sensor.py

@@ -1,33 +1,61 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_ID, CONF_RESOLUTION, UNIT_LUX, ICON_BRIGHTNESS_5
+from esphome.const import (
+    CONF_ID,
+    CONF_RESOLUTION,
+    DEVICE_CLASS_ILLUMINANCE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_LUX,
+    CONF_MEASUREMENT_DURATION,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-bh1750_ns = cg.esphome_ns.namespace('bh1750')
-BH1750Resolution = bh1750_ns.enum('BH1750Resolution')
+bh1750_ns = cg.esphome_ns.namespace("bh1750")
+BH1750Resolution = bh1750_ns.enum("BH1750Resolution")
 BH1750_RESOLUTIONS = {
     4.0: BH1750Resolution.BH1750_RESOLUTION_4P0_LX,
     1.0: BH1750Resolution.BH1750_RESOLUTION_1P0_LX,
     0.5: BH1750Resolution.BH1750_RESOLUTION_0P5_LX,
 }
 
-BH1750Sensor = bh1750_ns.class_('BH1750Sensor', sensor.Sensor, cg.PollingComponent, i2c.I2CDevice)
+BH1750Sensor = bh1750_ns.class_(
+    "BH1750Sensor", sensor.Sensor, cg.PollingComponent, i2c.I2CDevice
+)
 
-CONF_MEASUREMENT_TIME = 'measurement_time'
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_LUX, ICON_BRIGHTNESS_5, 1).extend({
-    cv.GenerateID(): cv.declare_id(BH1750Sensor),
-    cv.Optional(CONF_RESOLUTION, default=0.5): cv.enum(BH1750_RESOLUTIONS, float=True),
-    cv.Optional(CONF_MEASUREMENT_TIME, default=69): cv.int_range(min=31, max=254),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x23))
+CONF_MEASUREMENT_TIME = "measurement_time"
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        unit_of_measurement=UNIT_LUX,
+        accuracy_decimals=1,
+        device_class=DEVICE_CLASS_ILLUMINANCE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(BH1750Sensor),
+            cv.Optional(CONF_RESOLUTION, default=0.5): cv.enum(
+                BH1750_RESOLUTIONS, float=True
+            ),
+            cv.Optional(CONF_MEASUREMENT_DURATION, default=69): cv.int_range(
+                min=31, max=254
+            ),
+            cv.Optional(CONF_MEASUREMENT_TIME): cv.invalid(
+                "The 'measurement_time' option has been replaced with 'measurement_duration' in 1.18.0"
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x23))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield sensor.register_sensor(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    await i2c.register_i2c_device(var, config)
 
     cg.add(var.set_resolution(config[CONF_RESOLUTION]))
-    cg.add(var.set_measurement_time(config[CONF_MEASUREMENT_TIME]))
+    cg.add(var.set_measurement_duration(config[CONF_MEASUREMENT_DURATION]))

esphome/components/binary/__init__.py

@@ -1,3 +1,3 @@
 import esphome.codegen as cg
 
-binary_ns = cg.esphome_ns.namespace('binary')
+binary_ns = cg.esphome_ns.namespace("binary")

esphome/components/binary/fan/__init__.py

@@ -1,33 +1,39 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import fan, output
-from esphome.const import CONF_DIRECTION_OUTPUT, CONF_OSCILLATION_OUTPUT, \
-    CONF_OUTPUT, CONF_OUTPUT_ID
+from esphome.const import (
+    CONF_DIRECTION_OUTPUT,
+    CONF_OSCILLATION_OUTPUT,
+    CONF_OUTPUT,
+    CONF_OUTPUT_ID,
+)
 from .. import binary_ns
 
-BinaryFan = binary_ns.class_('BinaryFan', cg.Component)
+BinaryFan = binary_ns.class_("BinaryFan", cg.Component)
 
-CONFIG_SCHEMA = fan.FAN_SCHEMA.extend({
-    cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryFan),
-    cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
-    cv.Optional(CONF_DIRECTION_OUTPUT): cv.use_id(output.BinaryOutput),
-    cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = fan.FAN_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryFan),
+        cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
+        cv.Optional(CONF_DIRECTION_OUTPUT): cv.use_id(output.BinaryOutput),
+        cv.Optional(CONF_OSCILLATION_OUTPUT): cv.use_id(output.BinaryOutput),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
-    yield cg.register_component(var, config)
+    await cg.register_component(var, config)
 
-    fan_ = yield fan.create_fan_state(config)
+    fan_ = await fan.create_fan_state(config)
     cg.add(var.set_fan(fan_))
-    output_ = yield cg.get_variable(config[CONF_OUTPUT])
+    output_ = await cg.get_variable(config[CONF_OUTPUT])
     cg.add(var.set_output(output_))
 
     if CONF_OSCILLATION_OUTPUT in config:
-        oscillation_output = yield cg.get_variable(config[CONF_OSCILLATION_OUTPUT])
+        oscillation_output = await cg.get_variable(config[CONF_OSCILLATION_OUTPUT])
         cg.add(var.set_oscillating(oscillation_output))
 
     if CONF_DIRECTION_OUTPUT in config:
-        direction_output = yield cg.get_variable(config[CONF_DIRECTION_OUTPUT])
+        direction_output = await cg.get_variable(config[CONF_DIRECTION_OUTPUT])
         cg.add(var.set_direction(direction_output))

esphome/components/binary/fan/binary_fan.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace binary {
 
-static const char *TAG = "binary.fan";
+static const char *const TAG = "binary.fan";
 
 void binary::BinaryFan::dump_config() {
   ESP_LOGCONFIG(TAG, "Fan '%s':", this->fan_->get_name().c_str());
@@ -16,7 +16,7 @@ void binary::BinaryFan::dump_config() {
   }
 }
 void BinaryFan::setup() {
-  auto traits = fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr);
+  auto traits = fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr, 0);
   this->fan_->set_traits(traits);
   this->fan_->add_on_state_callback([this]() { this->next_update_ = true; });
 }

esphome/components/binary/light/__init__.py

@@ -4,17 +4,19 @@ from esphome.components import light, output
 from esphome.const import CONF_OUTPUT_ID, CONF_OUTPUT
 from .. import binary_ns
 
-BinaryLightOutput = binary_ns.class_('BinaryLightOutput', light.LightOutput)
+BinaryLightOutput = binary_ns.class_("BinaryLightOutput", light.LightOutput)
 
-CONFIG_SCHEMA = light.BINARY_LIGHT_SCHEMA.extend({
-    cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryLightOutput),
-    cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
-})
+CONFIG_SCHEMA = light.BINARY_LIGHT_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(BinaryLightOutput),
+        cv.Required(CONF_OUTPUT): cv.use_id(output.BinaryOutput),
+    }
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
-    yield light.register_light(var, config)
+    await light.register_light(var, config)
 
-    out = yield cg.get_variable(config[CONF_OUTPUT])
+    out = await cg.get_variable(config[CONF_OUTPUT])
     cg.add(var.set_output(out))

esphome/components/binary/light/binary_light_output.h

@@ -12,7 +12,7 @@ class BinaryLightOutput : public light::LightOutput {
   void set_output(output::BinaryOutput *output) { output_ = output; }
   light::LightTraits get_traits() override {
     auto traits = light::LightTraits();
-    traits.set_supports_brightness(false);
+    traits.set_supported_color_modes({light::ColorMode::ON_OFF});
     return traits;
   }
   void write_state(light::LightState *state) override {

esphome/components/binary_sensor/__init__.py

@@ -3,130 +3,261 @@ import esphome.config_validation as cv
 from esphome import automation, core
 from esphome.automation import Condition, maybe_simple_id
 from esphome.components import mqtt
-from esphome.const import CONF_DEVICE_CLASS, CONF_FILTERS, \
-    CONF_ID, CONF_INTERNAL, CONF_INVALID_COOLDOWN, CONF_INVERTED, \
-    CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_ON_CLICK, \
-    CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_ON_STATE, \
-    CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR, CONF_NAME, CONF_MQTT_ID
-from esphome.core import CORE, coroutine, coroutine_with_priority
+from esphome.const import (
+    CONF_DELAY,
+    CONF_DEVICE_CLASS,
+    CONF_DISABLED_BY_DEFAULT,
+    CONF_FILTERS,
+    CONF_ID,
+    CONF_INTERNAL,
+    CONF_INVALID_COOLDOWN,
+    CONF_INVERTED,
+    CONF_MAX_LENGTH,
+    CONF_MIN_LENGTH,
+    CONF_ON_CLICK,
+    CONF_ON_DOUBLE_CLICK,
+    CONF_ON_MULTI_CLICK,
+    CONF_ON_PRESS,
+    CONF_ON_RELEASE,
+    CONF_ON_STATE,
+    CONF_STATE,
+    CONF_TIMING,
+    CONF_TRIGGER_ID,
+    CONF_NAME,
+    CONF_MQTT_ID,
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BATTERY_CHARGING,
+    DEVICE_CLASS_COLD,
+    DEVICE_CLASS_CONNECTIVITY,
+    DEVICE_CLASS_DOOR,
+    DEVICE_CLASS_GARAGE_DOOR,
+    DEVICE_CLASS_GAS,
+    DEVICE_CLASS_HEAT,
+    DEVICE_CLASS_LIGHT,
+    DEVICE_CLASS_LOCK,
+    DEVICE_CLASS_MOISTURE,
+    DEVICE_CLASS_MOTION,
+    DEVICE_CLASS_MOVING,
+    DEVICE_CLASS_OCCUPANCY,
+    DEVICE_CLASS_OPENING,
+    DEVICE_CLASS_PLUG,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_PRESENCE,
+    DEVICE_CLASS_PROBLEM,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_VIBRATION,
+    DEVICE_CLASS_WINDOW,
+)
+from esphome.core import CORE, coroutine_with_priority
 from esphome.util import Registry
 
-CODEOWNERS = ['@esphome/core']
+CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
-    '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
-    'heat', 'light', 'lock', 'moisture', 'motion', 'moving', 'occupancy',
-    'opening', 'plug', 'power', 'presence', 'problem', 'safety', 'smoke',
-    'sound', 'vibration', 'window'
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BATTERY_CHARGING,
+    DEVICE_CLASS_COLD,
+    DEVICE_CLASS_CONNECTIVITY,
+    DEVICE_CLASS_DOOR,
+    DEVICE_CLASS_GARAGE_DOOR,
+    DEVICE_CLASS_GAS,
+    DEVICE_CLASS_HEAT,
+    DEVICE_CLASS_LIGHT,
+    DEVICE_CLASS_LOCK,
+    DEVICE_CLASS_MOISTURE,
+    DEVICE_CLASS_MOTION,
+    DEVICE_CLASS_MOVING,
+    DEVICE_CLASS_OCCUPANCY,
+    DEVICE_CLASS_OPENING,
+    DEVICE_CLASS_PLUG,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_PRESENCE,
+    DEVICE_CLASS_PROBLEM,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_VIBRATION,
+    DEVICE_CLASS_WINDOW,
 ]
 
 IS_PLATFORM_COMPONENT = True
 
-binary_sensor_ns = cg.esphome_ns.namespace('binary_sensor')
-BinarySensor = binary_sensor_ns.class_('BinarySensor', cg.Nameable)
-BinarySensorInitiallyOff = binary_sensor_ns.class_('BinarySensorInitiallyOff', BinarySensor)
-BinarySensorPtr = BinarySensor.operator('ptr')
+binary_sensor_ns = cg.esphome_ns.namespace("binary_sensor")
+BinarySensor = binary_sensor_ns.class_("BinarySensor", cg.Nameable)
+BinarySensorInitiallyOff = binary_sensor_ns.class_(
+    "BinarySensorInitiallyOff", BinarySensor
+)
+BinarySensorPtr = BinarySensor.operator("ptr")
 
 # Triggers
-PressTrigger = binary_sensor_ns.class_('PressTrigger', automation.Trigger.template())
-ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', automation.Trigger.template())
-ClickTrigger = binary_sensor_ns.class_('ClickTrigger', automation.Trigger.template())
-DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', automation.Trigger.template())
-MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', automation.Trigger.template(),
-                                            cg.Component)
-MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
-StateTrigger = binary_sensor_ns.class_('StateTrigger', automation.Trigger.template(bool))
-BinarySensorPublishAction = binary_sensor_ns.class_('BinarySensorPublishAction', automation.Action)
+PressTrigger = binary_sensor_ns.class_("PressTrigger", automation.Trigger.template())
+ReleaseTrigger = binary_sensor_ns.class_(
+    "ReleaseTrigger", automation.Trigger.template()
+)
+ClickTrigger = binary_sensor_ns.class_("ClickTrigger", automation.Trigger.template())
+DoubleClickTrigger = binary_sensor_ns.class_(
+    "DoubleClickTrigger", automation.Trigger.template()
+)
+MultiClickTrigger = binary_sensor_ns.class_(
+    "MultiClickTrigger", automation.Trigger.template(), cg.Component
+)
+MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")
+StateTrigger = binary_sensor_ns.class_(
+    "StateTrigger", automation.Trigger.template(bool)
+)
+BinarySensorPublishAction = binary_sensor_ns.class_(
+    "BinarySensorPublishAction", automation.Action
+)
 
 # Condition
-BinarySensorCondition = binary_sensor_ns.class_('BinarySensorCondition', Condition)
+BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Condition)
 
 # Filters
-Filter = binary_sensor_ns.class_('Filter')
-DelayedOnOffFilter = binary_sensor_ns.class_('DelayedOnOffFilter', Filter, cg.Component)
-DelayedOnFilter = binary_sensor_ns.class_('DelayedOnFilter', Filter, cg.Component)
-DelayedOffFilter = binary_sensor_ns.class_('DelayedOffFilter', Filter, cg.Component)
-InvertFilter = binary_sensor_ns.class_('InvertFilter', Filter)
-LambdaFilter = binary_sensor_ns.class_('LambdaFilter', Filter)
+Filter = binary_sensor_ns.class_("Filter")
+DelayedOnOffFilter = binary_sensor_ns.class_("DelayedOnOffFilter", Filter, cg.Component)
+DelayedOnFilter = binary_sensor_ns.class_("DelayedOnFilter", Filter, cg.Component)
+DelayedOffFilter = binary_sensor_ns.class_("DelayedOffFilter", Filter, cg.Component)
+InvertFilter = binary_sensor_ns.class_("InvertFilter", Filter)
+AutorepeatFilter = binary_sensor_ns.class_("AutorepeatFilter", Filter, cg.Component)
+LambdaFilter = binary_sensor_ns.class_("LambdaFilter", Filter)
 
 FILTER_REGISTRY = Registry()
-validate_filters = cv.validate_registry('filter', FILTER_REGISTRY)
+validate_filters = cv.validate_registry("filter", FILTER_REGISTRY)
 
 
-@FILTER_REGISTRY.register('invert', InvertFilter, {})
-def invert_filter_to_code(config, filter_id):
-    yield cg.new_Pvariable(filter_id)
+@FILTER_REGISTRY.register("invert", InvertFilter, {})
+async def invert_filter_to_code(config, filter_id):
+    return cg.new_Pvariable(filter_id)
 
 
-@FILTER_REGISTRY.register('delayed_on_off', DelayedOnOffFilter,
-                          cv.positive_time_period_milliseconds)
-def delayed_on_off_filter_to_code(config, filter_id):
+@FILTER_REGISTRY.register(
+    "delayed_on_off", DelayedOnOffFilter, cv.positive_time_period_milliseconds
+)
+async def delayed_on_off_filter_to_code(config, filter_id):
     var = cg.new_Pvariable(filter_id, config)
-    yield cg.register_component(var, {})
-    yield var
+    await cg.register_component(var, {})
+    return var
 
 
-@FILTER_REGISTRY.register('delayed_on', DelayedOnFilter,
-                          cv.positive_time_period_milliseconds)
-def delayed_on_filter_to_code(config, filter_id):
+@FILTER_REGISTRY.register(
+    "delayed_on", DelayedOnFilter, cv.positive_time_period_milliseconds
+)
+async def delayed_on_filter_to_code(config, filter_id):
     var = cg.new_Pvariable(filter_id, config)
-    yield cg.register_component(var, {})
-    yield var
+    await cg.register_component(var, {})
+    return var
 
 
-@FILTER_REGISTRY.register('delayed_off', DelayedOffFilter, cv.positive_time_period_milliseconds)
-def delayed_off_filter_to_code(config, filter_id):
+@FILTER_REGISTRY.register(
+    "delayed_off", DelayedOffFilter, cv.positive_time_period_milliseconds
+)
+async def delayed_off_filter_to_code(config, filter_id):
     var = cg.new_Pvariable(filter_id, config)
-    yield cg.register_component(var, {})
-    yield var
+    await cg.register_component(var, {})
+    return var
 
 
-@FILTER_REGISTRY.register('lambda', LambdaFilter, cv.returning_lambda)
-def lambda_filter_to_code(config, filter_id):
-    lambda_ = yield cg.process_lambda(config, [(bool, 'x')], return_type=cg.optional.template(bool))
-    yield cg.new_Pvariable(filter_id, lambda_)
+CONF_TIME_OFF = "time_off"
+CONF_TIME_ON = "time_on"
+
+DEFAULT_DELAY = "1s"
+DEFAULT_TIME_OFF = "100ms"
+DEFAULT_TIME_ON = "900ms"
 
 
-MULTI_CLICK_TIMING_SCHEMA = cv.Schema({
-    cv.Optional(CONF_STATE): cv.boolean,
-    cv.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds,
-})
+@FILTER_REGISTRY.register(
+    "autorepeat",
+    AutorepeatFilter,
+    cv.All(
+        cv.ensure_list(
+            {
+                cv.Optional(
+                    CONF_DELAY, default=DEFAULT_DELAY
+                ): cv.positive_time_period_milliseconds,
+                cv.Optional(
+                    CONF_TIME_OFF, default=DEFAULT_TIME_OFF
+                ): cv.positive_time_period_milliseconds,
+                cv.Optional(
+                    CONF_TIME_ON, default=DEFAULT_TIME_ON
+                ): cv.positive_time_period_milliseconds,
+            }
+        ),
+    ),
+)
+async def autorepeat_filter_to_code(config, filter_id):
+    timings = []
+    if len(config) > 0:
+        for conf in config:
+            timings.append((conf[CONF_DELAY], conf[CONF_TIME_OFF], conf[CONF_TIME_ON]))
+    else:
+        timings.append(
+            (
+                cv.time_period_str_unit(DEFAULT_DELAY).total_milliseconds,
+                cv.time_period_str_unit(DEFAULT_TIME_OFF).total_milliseconds,
+                cv.time_period_str_unit(DEFAULT_TIME_ON).total_milliseconds,
+            )
+        )
+    var = cg.new_Pvariable(filter_id, timings)
+    await cg.register_component(var, {})
+    return var
+
+
+@FILTER_REGISTRY.register("lambda", LambdaFilter, cv.returning_lambda)
+async def lambda_filter_to_code(config, filter_id):
+    lambda_ = await cg.process_lambda(
+        config, [(bool, "x")], return_type=cg.optional.template(bool)
+    )
+    return cg.new_Pvariable(filter_id, lambda_)
+
+
+MULTI_CLICK_TIMING_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_STATE): cv.boolean,
+        cv.Optional(CONF_MIN_LENGTH): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_MAX_LENGTH): cv.positive_time_period_milliseconds,
+    }
+)
 
 
 def parse_multi_click_timing_str(value):
     if not isinstance(value, str):
         return value
 
-    parts = value.lower().split(' ')
+    parts = value.lower().split(" ")
     if len(parts) != 5:
-        raise cv.Invalid("Multi click timing grammar consists of exactly 5 words, not {}"
-                         "".format(len(parts)))
+        raise cv.Invalid(
+            "Multi click timing grammar consists of exactly 5 words, not {}"
+            "".format(len(parts))
+        )
     try:
         state = cv.boolean(parts[0])
     except cv.Invalid:
+        # pylint: disable=raise-missing-from
         raise cv.Invalid("First word must either be ON or OFF, not {}".format(parts[0]))
 
-    if parts[1] != 'for':
+    if parts[1] != "for":
         raise cv.Invalid("Second word must be 'for', got {}".format(parts[1]))
 
-    if parts[2] == 'at':
-        if parts[3] == 'least':
+    if parts[2] == "at":
+        if parts[3] == "least":
             key = CONF_MIN_LENGTH
-        elif parts[3] == 'most':
+        elif parts[3] == "most":
             key = CONF_MAX_LENGTH
         else:
-            raise cv.Invalid("Third word after at must either be 'least' or 'most', got {}"
-                             "".format(parts[3]))
+            raise cv.Invalid(
+                "Third word after at must either be 'least' or 'most', got {}"
+                "".format(parts[3])
+            )
         try:
             length = cv.positive_time_period_milliseconds(parts[4])
         except cv.Invalid as err:
             raise cv.Invalid(f"Multi Click Grammar Parsing length failed: {err}")
-        return {
-            CONF_STATE: state,
-            key: str(length)
-        }
+        return {CONF_STATE: state, key: str(length)}
 
-    if parts[3] != 'to':
+    if parts[3] != "to":
         raise cv.Invalid("Multi click grammar: 4th word must be 'to'")
 
     try:
@@ -142,7 +273,7 @@ def parse_multi_click_timing_str(value):
     return {
         CONF_STATE: state,
         CONF_MIN_LENGTH: str(min_length),
-        CONF_MAX_LENGTH: str(max_length)
+        CONF_MAX_LENGTH: str(max_length),
     }
 
 
@@ -162,11 +293,15 @@ def validate_multi_click_timing(value):
 
         new_state = v_.get(CONF_STATE, not state)
         if new_state == state:
-            raise cv.Invalid("Timings must have alternating state. Indices {} and {} have "
-                             "the same state {}".format(i, i + 1, state))
+            raise cv.Invalid(
+                "Timings must have alternating state. Indices {} and {} have "
+                "the same state {}".format(i, i + 1, state)
+            )
         if max_length is not None and max_length < min_length:
-            raise cv.Invalid("Max length ({}) must be larger than min length ({})."
-                             "".format(max_length, min_length))
+            raise cv.Invalid(
+                "Max length ({}) must be larger than min length ({})."
+                "".format(max_length, min_length)
+            )
 
         state = new_state
         tim = {
@@ -179,51 +314,71 @@ def validate_multi_click_timing(value):
     return timings
 
 
-device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space='_')
+device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BinarySensor),
-    cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTBinarySensorComponent),
-
-    cv.Optional(CONF_DEVICE_CLASS): device_class,
-    cv.Optional(CONF_FILTERS): validate_filters,
-    cv.Optional(CONF_ON_PRESS): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PressTrigger),
-    }),
-    cv.Optional(CONF_ON_RELEASE): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ReleaseTrigger),
-    }),
-    cv.Optional(CONF_ON_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ClickTrigger),
-        cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DoubleClickTrigger),
-        cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger),
-        cv.Required(CONF_TIMING): cv.All([parse_multi_click_timing_str],
-                                         validate_multi_click_timing),
-        cv.Optional(CONF_INVALID_COOLDOWN, default='1s'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_STATE): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
-    }),
-
-    cv.Optional(CONF_INVERTED): cv.invalid(
-        "The inverted binary_sensor property has been replaced by the "
-        "new 'invert' binary  sensor filter. Please see "
-        "https://esphome.io/components/binary_sensor/index.html."
-    ),
-})
+BINARY_SENSOR_SCHEMA = cv.NAMEABLE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).extend(
+    {
+        cv.GenerateID(): cv.declare_id(BinarySensor),
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
+            mqtt.MQTTBinarySensorComponent
+        ),
+        cv.Optional(CONF_DEVICE_CLASS): device_class,
+        cv.Optional(CONF_FILTERS): validate_filters,
+        cv.Optional(CONF_ON_PRESS): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PressTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_RELEASE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ReleaseTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_CLICK): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ClickTrigger),
+                cv.Optional(
+                    CONF_MIN_LENGTH, default="50ms"
+                ): cv.positive_time_period_milliseconds,
+                cv.Optional(
+                    CONF_MAX_LENGTH, default="350ms"
+                ): cv.positive_time_period_milliseconds,
+            }
+        ),
+        cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DoubleClickTrigger),
+                cv.Optional(
+                    CONF_MIN_LENGTH, default="50ms"
+                ): cv.positive_time_period_milliseconds,
+                cv.Optional(
+                    CONF_MAX_LENGTH, default="350ms"
+                ): cv.positive_time_period_milliseconds,
+            }
+        ),
+        cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger),
+                cv.Required(CONF_TIMING): cv.All(
+                    [parse_multi_click_timing_str], validate_multi_click_timing
+                ),
+                cv.Optional(
+                    CONF_INVALID_COOLDOWN, default="1s"
+                ): cv.positive_time_period_milliseconds,
+            }
+        ),
+        cv.Optional(CONF_ON_STATE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
+            }
+        ),
+    }
+)
 
 
-@coroutine
-def setup_binary_sensor_core_(var, config):
+async def setup_binary_sensor_core_(var, config):
     cg.add(var.set_name(config[CONF_NAME]))
+    cg.add(var.set_disabled_by_default(config[CONF_DISABLED_BY_DEFAULT]))
     if CONF_INTERNAL in config:
         cg.add(var.set_internal(config[CONF_INTERNAL]))
     if CONF_DEVICE_CLASS in config:
@@ -231,88 +386,92 @@ def setup_binary_sensor_core_(var, config):
     if CONF_INVERTED in config:
         cg.add(var.set_inverted(config[CONF_INVERTED]))
     if CONF_FILTERS in config:
-        filters = yield cg.build_registry_list(FILTER_REGISTRY, config[CONF_FILTERS])
+        filters = await cg.build_registry_list(FILTER_REGISTRY, config[CONF_FILTERS])
         cg.add(var.add_filters(filters))
 
     for conf in config.get(CONF_ON_PRESS, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        yield automation.build_automation(trigger, [], conf)
+        await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_RELEASE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        yield automation.build_automation(trigger, [], conf)
+        await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_CLICK, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var,
-                                   conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH])
-        yield automation.build_automation(trigger, [], conf)
+        trigger = cg.new_Pvariable(
+            conf[CONF_TRIGGER_ID], var, conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH]
+        )
+        await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_DOUBLE_CLICK, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var,
-                                   conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH])
-        yield automation.build_automation(trigger, [], conf)
+        trigger = cg.new_Pvariable(
+            conf[CONF_TRIGGER_ID], var, conf[CONF_MIN_LENGTH], conf[CONF_MAX_LENGTH]
+        )
+        await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_MULTI_CLICK, []):
         timings = []
         for tim in conf[CONF_TIMING]:
-            timings.append(cg.StructInitializer(
-                MultiClickTriggerEvent,
-                ('state', tim[CONF_STATE]),
-                ('min_length', tim[CONF_MIN_LENGTH]),
-                ('max_length', tim.get(CONF_MAX_LENGTH, 4294967294)),
-            ))
+            timings.append(
+                cg.StructInitializer(
+                    MultiClickTriggerEvent,
+                    ("state", tim[CONF_STATE]),
+                    ("min_length", tim[CONF_MIN_LENGTH]),
+                    ("max_length", tim.get(CONF_MAX_LENGTH, 4294967294)),
+                )
+            )
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var, timings)
         if CONF_INVALID_COOLDOWN in conf:
             cg.add(trigger.set_invalid_cooldown(conf[CONF_INVALID_COOLDOWN]))
-        yield cg.register_component(trigger, conf)
-        yield automation.build_automation(trigger, [], conf)
+        await cg.register_component(trigger, conf)
+        await automation.build_automation(trigger, [], conf)
 
     for conf in config.get(CONF_ON_STATE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        yield automation.build_automation(trigger, [(bool, 'x')], conf)
+        await automation.build_automation(trigger, [(bool, "x")], conf)
 
     if CONF_MQTT_ID in config:
         mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
-        yield mqtt.register_mqtt_component(mqtt_, config)
+        await mqtt.register_mqtt_component(mqtt_, config)
 
 
-@coroutine
-def register_binary_sensor(var, config):
+async def register_binary_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_binary_sensor(var))
-    yield setup_binary_sensor_core_(var, config)
+    await setup_binary_sensor_core_(var, config)
 
 
-@coroutine
-def new_binary_sensor(config):
+async def new_binary_sensor(config):
     var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
-    yield register_binary_sensor(var, config)
-    yield var
+    await register_binary_sensor(var, config)
+    return var
 
 
-BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
-    cv.Required(CONF_ID): cv.use_id(BinarySensor),
-    cv.Optional(CONF_FOR): cv.invalid("This option has been removed in 1.13, please use the "
-                                      "'for' condition instead."),
-})
+BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(BinarySensor),
+    }
+)
 
 
-@automation.register_condition('binary_sensor.is_on', BinarySensorCondition,
-                               BINARY_SENSOR_CONDITION_SCHEMA)
-def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
-    paren = yield cg.get_variable(config[CONF_ID])
-    yield cg.new_Pvariable(condition_id, template_arg, paren, True)
+@automation.register_condition(
+    "binary_sensor.is_on", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
+)
+async def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, True)
 
 
-@automation.register_condition('binary_sensor.is_off', BinarySensorCondition,
-                               BINARY_SENSOR_CONDITION_SCHEMA)
-def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
-    paren = yield cg.get_variable(config[CONF_ID])
-    yield cg.new_Pvariable(condition_id, template_arg, paren, False)
+@automation.register_condition(
+    "binary_sensor.is_off", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
+)
+async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
 @coroutine_with_priority(100.0)
-def to_code(config):
-    cg.add_define('USE_BINARY_SENSOR')
+async def to_code(config):
+    cg.add_define("USE_BINARY_SENSOR")
     cg.add_global(binary_sensor_ns.using)

esphome/components/binary_sensor/automation.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace binary_sensor {
 
-static const char *TAG = "binary_sensor.automation";
+static const char *const TAG = "binary_sensor.automation";
 
 void binary_sensor::MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
@@ -80,6 +80,10 @@ void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_not_valid");
 }
 void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+  if (min_length == 0) {
+    this->is_valid_ = true;
+    return;
+  }
   this->is_valid_ = false;
   this->set_timeout("is_valid", min_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You can now %s the button.", this->parent_->state ? "RELEASE" : "PRESS");

esphome/components/binary_sensor/automation.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
@@ -87,8 +89,8 @@ class DoubleClickTrigger : public Trigger<> {
 
 class MultiClickTrigger : public Trigger<>, public Component {
  public:
-  explicit MultiClickTrigger(BinarySensor *parent, const std::vector<MultiClickTriggerEvent> &timing)
-      : parent_(parent), timing_(timing) {}
+  explicit MultiClickTrigger(BinarySensor *parent, std::vector<MultiClickTriggerEvent> timing)
+      : parent_(parent), timing_(std::move(timing)) {}
 
   void setup() override {
     this->last_state_ = this->parent_->state;

esphome/components/binary_sensor/binary_sensor.cpp

@@ -5,7 +5,7 @@ namespace esphome {
 
 namespace binary_sensor {
 
-static const char *TAG = "binary_sensor";
+static const char *const TAG = "binary_sensor";
 
 void BinarySensor::add_on_state_callback(std::function<void(bool)> &&callback) {
   this->state_callback_.add(std::move(callback));
@@ -61,7 +61,7 @@ void BinarySensor::add_filter(Filter *filter) {
     last_filter->next_ = filter;
   }
 }
-void BinarySensor::add_filters(std::vector<Filter *> filters) {
+void BinarySensor::add_filters(const std::vector<Filter *> &filters) {
   for (Filter *filter : filters) {
     this->add_filter(filter);
   }

esphome/components/binary_sensor/binary_sensor.h

@@ -9,10 +9,10 @@ namespace esphome {
 namespace binary_sensor {
 
 #define LOG_BINARY_SENSOR(prefix, type, obj) \
-  if (obj != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, obj->get_name().c_str()); \
-    if (!obj->get_device_class().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, obj->get_device_class().c_str()); \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    if (!(obj)->get_device_class().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
   }
 
@@ -60,7 +60,7 @@ class BinarySensor : public Nameable {
   std::string get_device_class();
 
   void add_filter(Filter *filter);
-  void add_filters(std::vector<Filter *> filters);
+  void add_filters(const std::vector<Filter *> &filters);
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)

esphome/components/binary_sensor/filter.cpp

@@ -1,11 +1,13 @@
 #include "filter.h"
+
 #include "binary_sensor.h"
+#include <utility>
 
 namespace esphome {
 
 namespace binary_sensor {
 
-static const char *TAG = "sensor.filter";
+static const char *const TAG = "sensor.filter";
 
 void Filter::output(bool value, bool is_initial) {
   if (!this->dedup_.next(value))
@@ -64,7 +66,51 @@ float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARD
 
 optional<bool> InvertFilter::new_value(bool value, bool is_initial) { return !value; }
 
-LambdaFilter::LambdaFilter(const std::function<optional<bool>(bool)> &f) : f_(f) {}
+AutorepeatFilter::AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings) : timings_(std::move(timings)) {}
+
+optional<bool> AutorepeatFilter::new_value(bool value, bool is_initial) {
+  if (value) {
+    // Ignore if already running
+    if (this->active_timing_ != 0)
+      return {};
+
+    this->next_timing_();
+    return true;
+  } else {
+    this->cancel_timeout("TIMING");
+    this->cancel_timeout("ON_OFF");
+    this->active_timing_ = 0;
+    return false;
+  }
+}
+
+void AutorepeatFilter::next_timing_() {
+  // Entering this method
+  // 1st time: starts waiting the first delay
+  // 2nd time: starts waiting the second delay and starts toggling with the first time_off / _on
+  // last time: no delay to start but have to bump the index to reflect the last
+  if (this->active_timing_ < this->timings_.size())
+    this->set_timeout("TIMING", this->timings_[this->active_timing_].delay, [this]() { this->next_timing_(); });
+
+  if (this->active_timing_ <= this->timings_.size()) {
+    this->active_timing_++;
+  }
+
+  if (this->active_timing_ == 2)
+    this->next_value_(false);
+
+  // Leaving this method: if the toggling is started, it has to use [active_timing_ - 2] for the intervals
+}
+
+void AutorepeatFilter::next_value_(bool val) {
+  const AutorepeatFilterTiming &timing = this->timings_[this->active_timing_ - 2];
+  this->output(val, false);  // This is at least the second one so not initial
+  this->set_timeout("ON_OFF", val ? timing.time_on : timing.time_off, [this, val]() { this->next_value_(!val); });
+}
+
+float AutorepeatFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
+
+LambdaFilter::LambdaFilter(std::function<optional<bool>(bool)> f) : f_(std::move(f)) {}
 
 optional<bool> LambdaFilter::new_value(bool value, bool is_initial) { return this->f_(value); }
 

esphome/components/binary_sensor/filter.h

@@ -66,9 +66,36 @@ class InvertFilter : public Filter {
   optional<bool> new_value(bool value, bool is_initial) override;
 };
 
+struct AutorepeatFilterTiming {
+  AutorepeatFilterTiming(uint32_t delay, uint32_t off, uint32_t on) {
+    this->delay = delay;
+    this->time_off = off;
+    this->time_on = on;
+  }
+  uint32_t delay;
+  uint32_t time_off;
+  uint32_t time_on;
+};
+
+class AutorepeatFilter : public Filter, public Component {
+ public:
+  explicit AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings);
+
+  optional<bool> new_value(bool value, bool is_initial) override;
+
+  float get_setup_priority() const override;
+
+ protected:
+  void next_timing_();
+  void next_value_(bool val);
+
+  std::vector<AutorepeatFilterTiming> timings_;
+  uint8_t active_timing_{0};
+};
+
 class LambdaFilter : public Filter {
  public:
-  explicit LambdaFilter(const std::function<optional<bool>(bool)> &f);
+  explicit LambdaFilter(std::function<optional<bool>(bool)> f);
 
   optional<bool> new_value(bool value, bool is_initial) override;
 

esphome/components/binary_sensor_map/binary_sensor_map.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace binary_sensor_map {
 
-static const char *TAG = "binary_sensor_map";
+static const char *const TAG = "binary_sensor_map";
 
 void BinarySensorMap::dump_config() { LOG_SENSOR("  ", "binary_sensor_map", this); }
 

esphome/components/binary_sensor_map/sensor.py

@@ -2,14 +2,24 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 
 from esphome.components import sensor, binary_sensor
-from esphome.const import CONF_ID, CONF_CHANNELS, CONF_VALUE, CONF_TYPE, UNIT_EMPTY, \
-    ICON_CHECK_CIRCLE_OUTLINE, CONF_BINARY_SENSOR, CONF_GROUP
+from esphome.const import (
+    CONF_ID,
+    CONF_CHANNELS,
+    CONF_VALUE,
+    CONF_TYPE,
+    ICON_CHECK_CIRCLE_OUTLINE,
+    CONF_BINARY_SENSOR,
+    CONF_GROUP,
+    STATE_CLASS_NONE,
+)
 
-DEPENDENCIES = ['binary_sensor']
+DEPENDENCIES = ["binary_sensor"]
 
-binary_sensor_map_ns = cg.esphome_ns.namespace('binary_sensor_map')
-BinarySensorMap = binary_sensor_map_ns.class_('BinarySensorMap', cg.Component, sensor.Sensor)
-SensorMapType = binary_sensor_map_ns.enum('SensorMapType')
+binary_sensor_map_ns = cg.esphome_ns.namespace("binary_sensor_map")
+BinarySensorMap = binary_sensor_map_ns.class_(
+    "BinarySensorMap", cg.Component, sensor.Sensor
+)
+SensorMapType = binary_sensor_map_ns.enum("SensorMapType")
 
 SENSOR_MAP_TYPES = {
     CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
@@ -20,22 +30,33 @@ entry = {
     cv.Required(CONF_VALUE): cv.float_,
 }
 
-CONFIG_SCHEMA = cv.typed_schema({
-    CONF_GROUP: sensor.sensor_schema(UNIT_EMPTY, ICON_CHECK_CIRCLE_OUTLINE, 0).extend({
-        cv.GenerateID(): cv.declare_id(BinarySensorMap),
-        cv.Required(CONF_CHANNELS): cv.All(cv.ensure_list(entry), cv.Length(min=1)),
-    }),
-}, lower=True)
+CONFIG_SCHEMA = cv.typed_schema(
+    {
+        CONF_GROUP: sensor.sensor_schema(
+            icon=ICON_CHECK_CIRCLE_OUTLINE,
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_NONE,
+        ).extend(
+            {
+                cv.GenerateID(): cv.declare_id(BinarySensorMap),
+                cv.Required(CONF_CHANNELS): cv.All(
+                    cv.ensure_list(entry), cv.Length(min=1)
+                ),
+            }
+        ),
+    },
+    lower=True,
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
 
     constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
     cg.add(var.set_sensor_type(constant))
 
     for ch in config[CONF_CHANNELS]:
-        input_var = yield cg.get_variable(ch[CONF_BINARY_SENSOR])
+        input_var = await cg.get_variable(ch[CONF_BINARY_SENSOR])
         cg.add(var.add_channel(input_var, ch[CONF_VALUE]))

esphome/components/ble_client/__init__.py

@@ -0,0 +1,85 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import esp32_ble_tracker
+from esphome.const import (
+    CONF_ID,
+    CONF_MAC_ADDRESS,
+    CONF_NAME,
+    CONF_ON_CONNECT,
+    CONF_ON_DISCONNECT,
+    CONF_TRIGGER_ID,
+)
+from esphome import automation
+
+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
+)
+BLEClientNode = ble_client_ns.class_("BLEClientNode")
+BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
+# Triggers
+BLEClientConnectTrigger = ble_client_ns.class_(
+    "BLEClientConnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
+)
+BLEClientDisconnectTrigger = ble_client_ns.class_(
+    "BLEClientDisconnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
+)
+
+# Espressif platformio framework is built with MAX_BLE_CONN to 3, so
+# enforce this in yaml checks.
+MULTI_CONF = 3
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BLEClient),
+            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_NAME): cv.string,
+            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientConnectTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientDisconnectTrigger
+                    ),
+                }
+            ),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+)
+
+CONF_BLE_CLIENT_ID = "ble_client_id"
+
+BLE_CLIENT_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
+    }
+)
+
+
+async def register_ble_node(var, config):
+    parent = await cg.get_variable(config[CONF_BLE_CLIENT_ID])
+    cg.add(parent.register_ble_node(var))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_client(var, config)
+    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+    for conf in config.get(CONF_ON_CONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_DISCONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)

esphome/components/ble_client/automation.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/components/ble_client/ble_client.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+class BLEClientConnectTrigger : public Trigger<>, public BLEClientNode {
+ public:
+  explicit BLEClientConnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
+  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) {
+    if (event == ESP_GATTC_OPEN_EVT && param->open.status == ESP_GATT_OK)
+      this->trigger();
+    if (event == ESP_GATTC_SEARCH_CMPL_EVT)
+      this->node_state = espbt::ClientState::Established;
+  }
+};
+
+class BLEClientDisconnectTrigger : public Trigger<>, public BLEClientNode {
+ public:
+  explicit BLEClientDisconnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
+  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) {
+    if (event == ESP_GATTC_DISCONNECT_EVT && memcmp(param->disconnect.remote_bda, this->parent_->remote_bda, 6) == 0)
+      this->trigger();
+    if (event == ESP_GATTC_SEARCH_CMPL_EVT)
+      this->node_state = espbt::ClientState::Established;
+  }
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/ble_client.cpp

@@ -0,0 +1,392 @@
+#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"
+#include "ble_client.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *const TAG = "ble_client";
+
+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);
+  this->enabled = true;
+}
+
+void BLEClient::loop() {
+  if (this->state() == espbt::ClientState::Discovered) {
+    this->connect();
+  }
+  for (auto *node : this->nodes_)
+    node->loop();
+}
+
+void BLEClient::dump_config() {
+  ESP_LOGCONFIG(TAG, "BLE Client:");
+  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
+}
+
+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;
+  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;
+}
+
+void BLEClient::set_enabled(bool enabled) {
+  if (enabled == this->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);
+    if (ret) {
+      ESP_LOGW(TAG, "esp_ble_gattc_close error, address=%s status=%d", this->address_str().c_str(), ret);
+    }
+  }
+  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, BLE_ADDR_TYPE_PUBLIC, 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,
+                                    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());
+      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;
+      }
+      this->conn_id = param->open.conn_id;
+      auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if, param->open.conn_id);
+      if (ret) {
+        ESP_LOGW(TAG, "esp_ble_gattc_send_mtu_req failed, status=%d", ret);
+      }
+      break;
+    }
+    case ESP_GATTC_CFG_MTU_EVT: {
+      if (param->cfg_mtu.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "cfg_mtu to %s failed, status %d", this->address_str().c_str(), 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, NULL);
+      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", this->address_str().c_str());
+      for (auto &svc : this->services_)
+        delete svc;
+      this->services_.clear();
+      this->set_states(espbt::ClientState::Idle);
+      break;
+    }
+    case ESP_GATTC_SEARCH_RES_EVT: {
+      BLEService *ble_service = new BLEService();
+      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;
+      }
+      uint8_t notify_en = 1;
+      auto status = esp_ble_gattc_write_char_descr(this->gattc_if, this->conn_id, descr->handle, sizeof(notify_en),
+                                                   &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;
+    }
+
+    default:
+      break;
+  }
+  for (auto *node : this->nodes_)
+    node->gattc_event_handler(event, esp_gattc_if, param);
+
+  // Delete characteristics after clients have used them to save RAM.
+  if (!all_established && this->all_nodes_established()) {
+    for (auto &svc : this->services_)
+      delete svc;
+    this->services_.clear();
+  }
+}
+
+// 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;
+}
+
+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();
+    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;
+}
+
+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();
+    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));
+}
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/ble_client.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <string>
+#include <array>
+#include <esp_gap_ble_api.h>
+#include <esp_gattc_api.h>
+#include <esp_bt_defs.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+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(){};
+  void set_address(uint64_t address) { address_ = address; }
+  espbt::ESPBTClient *client;
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  espbt::ClientState node_state;
+
+  BLEClient *parent() { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_;
+  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);
+
+  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 {
+ public:
+  void setup() override;
+  void dump_config() override;
+  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);
+  bool parse_device(const espbt::ESPBTDevice &device) override;
+  void on_scan_end() override {}
+  void connect();
+
+  void set_address(uint64_t address) { this->address = address; }
+
+  void set_enabled(bool enabled);
+
+  void register_ble_node(BLEClientNode *node) {
+    node->client = this;
+    node->set_ble_client_parent(this);
+    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;
+  uint16_t conn_id;
+  uint64_t address;
+  bool enabled;
+  std::string address_str() const;
+
+ 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;
+  }
+
+  std::vector<BLEClientNode *> nodes_;
+  std::vector<BLEService *> services_;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/sensor/__init__.py

@@ -0,0 +1,127 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, ble_client, esp32_ble_tracker
+from esphome.const import (
+    CONF_ID,
+    CONF_LAMBDA,
+    STATE_CLASS_NONE,
+    CONF_TRIGGER_ID,
+    CONF_SERVICE_UUID,
+)
+from esphome import automation
+from .. import ble_client_ns
+
+DEPENDENCIES = ["ble_client"]
+
+CONF_CHARACTERISTIC_UUID = "characteristic_uuid"
+CONF_DESCRIPTOR_UUID = "descriptor_uuid"
+
+CONF_NOTIFY = "notify"
+CONF_ON_NOTIFY = "on_notify"
+
+adv_data_t = cg.std_vector.template(cg.uint8)
+adv_data_t_const_ref = adv_data_t.operator("ref").operator("const")
+
+BLESensor = ble_client_ns.class_(
+    "BLESensor", sensor.Sensor, cg.PollingComponent, ble_client.BLEClientNode
+)
+BLESensorNotifyTrigger = ble_client_ns.class_(
+    "BLESensorNotifyTrigger", automation.Trigger.template(cg.float_)
+)
+
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        accuracy_decimals=0,
+        state_class=STATE_CLASS_NONE,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLESensor),
+            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)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    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_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_hex_array(config[CONF_CHARACTERISTIC_UUID])
+        cg.add(var.set_char_uuid128(uuid128))
+
+    if CONF_DESCRIPTOR_UUID in config:
+        if len(config[CONF_DESCRIPTOR_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+            cg.add(
+                var.set_descr_uuid16(
+                    esp32_ble_tracker.as_hex(config[CONF_DESCRIPTOR_UUID])
+                )
+            )
+        elif len(config[CONF_DESCRIPTOR_UUID]) == len(
+            esp32_ble_tracker.bt_uuid32_format
+        ):
+            cg.add(
+                var.set_descr_uuid32(
+                    esp32_ble_tracker.as_hex(config[CONF_DESCRIPTOR_UUID])
+                )
+            )
+        elif len(config[CONF_DESCRIPTOR_UUID]) == len(
+            esp32_ble_tracker.bt_uuid128_format
+        ):
+            uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_DESCRIPTOR_UUID])
+            cg.add(var.set_descr_uuid128(uuid128))
+
+    if CONF_LAMBDA in config:
+        lambda_ = await cg.process_lambda(
+            config[CONF_LAMBDA], [(adv_data_t_const_ref, "x")], return_type=cg.float_
+        )
+        cg.add(var.set_data_to_value(lambda_))
+
+    await cg.register_component(var, config)
+    await ble_client.register_ble_node(var, config)
+    cg.add(var.set_enable_notify(config[CONF_NOTIFY]))
+    await sensor.register_sensor(var, config)
+    for conf in config.get(CONF_ON_NOTIFY, []):
+        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)

esphome/components/ble_client/sensor/automation.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/components/ble_client/sensor/ble_sensor.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+class BLESensorNotifyTrigger : public Trigger<float>, public BLESensor {
+ public:
+  explicit BLESensorNotifyTrigger(BLESensor *sensor) { sensor_ = sensor; }
+  void 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_SEARCH_CMPL_EVT: {
+        this->sensor_->node_state = espbt::ClientState::Established;
+        break;
+      }
+      case ESP_GATTC_NOTIFY_EVT: {
+        if (param->notify.conn_id != this->sensor_->parent()->conn_id || param->notify.handle != this->sensor_->handle)
+          break;
+        this->trigger(this->sensor_->parent()->parse_char_value(param->notify.value, param->notify.value_len));
+      }
+      default:
+        break;
+    }
+  }
+
+ protected:
+  BLESensor *sensor_;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -0,0 +1,138 @@
+#include "ble_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 ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *const TAG = "ble_sensor";
+
+uint32_t BLESensor::hash_base() { return 343459825UL; }
+
+void BLESensor::loop() {}
+
+void BLESensor::dump_config() {
+  LOG_SENSOR("", "BLE Sensor", this);
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Descriptor UUID    : %s", this->descr_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Notifications      : %s", YESNO(this->notify_));
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void BLESensor::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->handle = 0;
+      auto chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
+      if (chr == nullptr) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", this->service_uuid_.to_string().c_str(),
+                 this->char_uuid_.to_string().c_str());
+        break;
+      }
+      this->handle = chr->handle;
+      if (this->descr_uuid_.get_uuid().len > 0) {
+        auto descr = chr->get_descriptor(this->descr_uuid_);
+        if (descr == nullptr) {
+          this->status_set_warning();
+          this->publish_state(NAN);
+          ESP_LOGW(TAG, "No sensor descriptor found at service %s char %s descr %s",
+                   this->service_uuid_.to_string().c_str(), this->char_uuid_.to_string().c_str(),
+                   this->descr_uuid_.to_string().c_str());
+          break;
+        }
+        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);
+        if (status) {
+          ESP_LOGW(TAG, "esp_ble_gattc_register_for_notify failed, status=%d", status);
+        }
+      } else {
+        this->node_state = espbt::ClientState::Established;
+      }
+      break;
+    }
+    case ESP_GATTC_READ_CHAR_EVT: {
+      if (param->read.conn_id != this->parent()->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);
+        break;
+      }
+      if (param->read.handle == this->handle) {
+        this->status_clear_warning();
+        this->publish_state(this->parse_data(param->read.value, param->read.value_len));
+      }
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.conn_id != this->parent()->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]);
+      this->publish_state(this->parse_data(param->notify.value, param->notify.value_len));
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      this->node_state = espbt::ClientState::Established;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+float BLESensor::parse_data(uint8_t *value, uint16_t value_len) {
+  if (this->data_to_value_func_.has_value()) {
+    std::vector<uint8_t> data(value, value + value_len);
+    return (*this->data_to_value_func_)(data);
+  } else {
+    return value[0];
+  }
+}
+
+void BLESensor::update() {
+  if (this->node_state != espbt::ClientState::Established) {
+    ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str());
+    return;
+  }
+  if (this->handle == 0) {
+    ESP_LOGW(TAG, "[%s] Cannot poll, no service or characteristic found", this->get_name().c_str());
+    return;
+  }
+
+  auto status =
+      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle, ESP_GATT_AUTH_REQ_NONE);
+  if (status) {
+    this->status_set_warning();
+    this->publish_state(NAN);
+    ESP_LOGW(TAG, "[%s] Error sending read request for sensor, status=%d", this->get_name().c_str(), status);
+  }
+}
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/sensor/ble_sensor.h

@@ -0,0 +1,51 @@
+#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 ARDUINO_ARCH_ESP32
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+using data_to_value_t = std::function<float(std::vector<uint8_t>)>;
+
+class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClientNode {
+ public:
+  void loop() override;
+  void update() 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;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  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 set_descr_uuid16(uint16_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+  void set_data_to_value(data_to_value_t &&lambda_) { this->data_to_value_func_ = lambda_; }
+  void set_enable_notify(bool notify) { this->notify_ = notify; }
+  uint16_t handle;
+
+ protected:
+  uint32_t hash_base() override;
+  float parse_data(uint8_t *value, uint16_t value_len);
+  optional<data_to_value_t> data_to_value_func_{};
+  bool notify_;
+  espbt::ESPBTUUID service_uuid_;
+  espbt::ESPBTUUID char_uuid_;
+  espbt::ESPBTUUID descr_uuid_;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/switch/__init__.py

@@ -0,0 +1,30 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import switch, ble_client
+from esphome.const import CONF_ICON, CONF_ID, CONF_INVERTED, ICON_BLUETOOTH
+from .. import ble_client_ns
+
+BLEClientSwitch = ble_client_ns.class_(
+    "BLEClientSwitch", switch.Switch, cg.Component, ble_client.BLEClientNode
+)
+
+CONFIG_SCHEMA = (
+    switch.SWITCH_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLEClientSwitch),
+            cv.Optional(CONF_INVERTED): cv.invalid(
+                "BLE client switches do not support inverted mode!"
+            ),
+            cv.Optional(CONF_ICON, default=ICON_BLUETOOTH): switch.icon,
+        }
+    )
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await switch.register_switch(var, config)
+    await ble_client.register_ble_node(var, config)

esphome/components/ble_client/switch/ble_switch.cpp

@@ -0,0 +1,39 @@
+#include "ble_switch.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *const TAG = "ble_switch";
+
+void BLEClientSwitch::write_state(bool state) {
+  this->parent_->set_enabled(state);
+  this->publish_state(state);
+}
+
+void BLEClientSwitch::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_REG_EVT:
+      this->publish_state(this->parent_->enabled);
+      break;
+    case ESP_GATTC_OPEN_EVT:
+      this->node_state = espbt::ClientState::Established;
+      break;
+    case ESP_GATTC_DISCONNECT_EVT:
+      this->node_state = espbt::ClientState::Idle;
+      this->publish_state(this->parent_->enabled);
+      break;
+    default:
+      break;
+  }
+}
+
+void BLEClientSwitch::dump_config() { LOG_SWITCH("", "BLE Client Switch", this); }
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/switch/ble_switch.h

@@ -0,0 +1,30 @@
+#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/switch/switch.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class BLEClientSwitch : public switch_::Switch, public Component, public BLEClientNode {
+ public:
+  void dump_config() override;
+  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;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_presence/binary_sensor.py

@@ -3,34 +3,52 @@ import esphome.config_validation as cv
 from esphome.components import binary_sensor, esp32_ble_tracker
 from esphome.const import CONF_MAC_ADDRESS, CONF_SERVICE_UUID, CONF_ID
 
-DEPENDENCIES = ['esp32_ble_tracker']
+DEPENDENCIES = ["esp32_ble_tracker"]
 
-ble_presence_ns = cg.esphome_ns.namespace('ble_presence')
-BLEPresenceDevice = ble_presence_ns.class_('BLEPresenceDevice', binary_sensor.BinarySensor,
-                                           cg.Component, esp32_ble_tracker.ESPBTDeviceListener)
+ble_presence_ns = cg.esphome_ns.namespace("ble_presence")
+BLEPresenceDevice = ble_presence_ns.class_(
+    "BLEPresenceDevice",
+    binary_sensor.BinarySensor,
+    cg.Component,
+    esp32_ble_tracker.ESPBTDeviceListener,
+)
 
-CONFIG_SCHEMA = cv.All(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
-    cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
-    cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
-}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
-    cv.COMPONENT_SCHEMA), cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID))
+CONFIG_SCHEMA = cv.All(
+    binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
+            cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield esp32_ble_tracker.register_ble_device(var, config)
-    yield binary_sensor.register_binary_sensor(var, config)
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    await binary_sensor.register_binary_sensor(var, config)
 
     if CONF_MAC_ADDRESS in config:
         cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
 
     if CONF_SERVICE_UUID in config:
         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])))
+            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])))
+            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_hex_array(config[CONF_SERVICE_UUID])
             cg.add(var.set_service_uuid128(uuid128))

esphome/components/ble_presence/ble_presence_device.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace ble_presence {
 
-static const char *TAG = "ble_presence";
+static const char *const TAG = "ble_presence";
 
 void BLEPresenceDevice::dump_config() { LOG_BINARY_SENSOR("", "BLE Presence", this); }
 

esphome/components/ble_rssi/ble_rssi_sensor.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace ble_rssi {
 
-static const char *TAG = "ble_rssi";
+static const char *const TAG = "ble_rssi";
 
 void BLERSSISensor::dump_config() { LOG_SENSOR("", "BLE RSSI Sensor", this); }
 

esphome/components/ble_rssi/sensor.py

@@ -1,36 +1,64 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, esp32_ble_tracker
-from esphome.const import CONF_SERVICE_UUID, CONF_MAC_ADDRESS, CONF_ID, UNIT_DECIBEL, ICON_SIGNAL
+from esphome.const import (
+    CONF_SERVICE_UUID,
+    CONF_MAC_ADDRESS,
+    CONF_ID,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_DECIBEL,
+)
 
-DEPENDENCIES = ['esp32_ble_tracker']
+DEPENDENCIES = ["esp32_ble_tracker"]
 
-ble_rssi_ns = cg.esphome_ns.namespace('ble_rssi')
-BLERSSISensor = ble_rssi_ns.class_('BLERSSISensor', sensor.Sensor, cg.Component,
-                                   esp32_ble_tracker.ESPBTDeviceListener)
+ble_rssi_ns = cg.esphome_ns.namespace("ble_rssi")
+BLERSSISensor = ble_rssi_ns.class_(
+    "BLERSSISensor", sensor.Sensor, cg.Component, esp32_ble_tracker.ESPBTDeviceListener
+)
 
-CONFIG_SCHEMA = cv.All(sensor.sensor_schema(UNIT_DECIBEL, ICON_SIGNAL, 0).extend({
-    cv.GenerateID(): cv.declare_id(BLERSSISensor),
-    cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
-    cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
-}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
-    cv.COMPONENT_SCHEMA), cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID))
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        unit_of_measurement=UNIT_DECIBEL,
+        accuracy_decimals=0,
+        device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLERSSISensor),
+            cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield esp32_ble_tracker.register_ble_device(var, config)
-    yield sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    await sensor.register_sensor(var, config)
 
     if CONF_MAC_ADDRESS in config:
         cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
 
     if CONF_SERVICE_UUID in config:
         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])))
+            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])))
+            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_hex_array(config[CONF_SERVICE_UUID])
             cg.add(var.set_service_uuid128(uuid128))

esphome/components/ble_scanner/ble_scanner.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace ble_scanner {
 
-static const char *TAG = "ble_scanner";
+static const char *const TAG = "ble_scanner";
 
 void BLEScanner::dump_config() { LOG_TEXT_SENSOR("", "BLE Scanner", this); }
 

esphome/components/ble_scanner/text_sensor.py

@@ -3,20 +3,29 @@ import esphome.config_validation as cv
 from esphome.components import text_sensor, esp32_ble_tracker
 from esphome.const import CONF_ID
 
-DEPENDENCIES = ['esp32_ble_tracker']
+DEPENDENCIES = ["esp32_ble_tracker"]
 
-ble_scanner_ns = cg.esphome_ns.namespace('ble_scanner')
-BLEScanner = ble_scanner_ns.class_('BLEScanner', text_sensor.TextSensor, cg.Component,
-                                   esp32_ble_tracker.ESPBTDeviceListener)
+ble_scanner_ns = cg.esphome_ns.namespace("ble_scanner")
+BLEScanner = ble_scanner_ns.class_(
+    "BLEScanner",
+    text_sensor.TextSensor,
+    cg.Component,
+    esp32_ble_tracker.ESPBTDeviceListener,
+)
 
-CONFIG_SCHEMA = cv.All(text_sensor.TEXT_SENSOR_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BLEScanner),
-}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
-    cv.COMPONENT_SCHEMA))
+CONFIG_SCHEMA = cv.All(
+    text_sensor.TEXT_SENSOR_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLEScanner),
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield esp32_ble_tracker.register_ble_device(var, config)
-    yield text_sensor.register_text_sensor(var, config)
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    await text_sensor.register_text_sensor(var, config)

esphome/components/bme280/bme280.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bme280 {
 
-static const char *TAG = "bme280.sensor";
+static const char *const TAG = "bme280.sensor";
 
 static const uint8_t BME280_REGISTER_DIG_T1 = 0x88;
 static const uint8_t BME280_REGISTER_DIG_T2 = 0x8A;

esphome/components/bme280/sensor.py

@@ -1,75 +1,118 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_OVERSAMPLING, \
-    CONF_PRESSURE, CONF_TEMPERATURE, ICON_THERMOMETER, \
-    UNIT_CELSIUS, UNIT_HECTOPASCAL, ICON_GAUGE, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_IIR_FILTER,
+    CONF_OVERSAMPLING,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    UNIT_PERCENT,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-bme280_ns = cg.esphome_ns.namespace('bme280')
-BME280Oversampling = bme280_ns.enum('BME280Oversampling')
+bme280_ns = cg.esphome_ns.namespace("bme280")
+BME280Oversampling = bme280_ns.enum("BME280Oversampling")
 OVERSAMPLING_OPTIONS = {
-    'NONE': BME280Oversampling.BME280_OVERSAMPLING_NONE,
-    '1X': BME280Oversampling.BME280_OVERSAMPLING_1X,
-    '2X': BME280Oversampling.BME280_OVERSAMPLING_2X,
-    '4X': BME280Oversampling.BME280_OVERSAMPLING_4X,
-    '8X': BME280Oversampling.BME280_OVERSAMPLING_8X,
-    '16X': BME280Oversampling.BME280_OVERSAMPLING_16X,
+    "NONE": BME280Oversampling.BME280_OVERSAMPLING_NONE,
+    "1X": BME280Oversampling.BME280_OVERSAMPLING_1X,
+    "2X": BME280Oversampling.BME280_OVERSAMPLING_2X,
+    "4X": BME280Oversampling.BME280_OVERSAMPLING_4X,
+    "8X": BME280Oversampling.BME280_OVERSAMPLING_8X,
+    "16X": BME280Oversampling.BME280_OVERSAMPLING_16X,
 }
 
-BME280IIRFilter = bme280_ns.enum('BME280IIRFilter')
+BME280IIRFilter = bme280_ns.enum("BME280IIRFilter")
 IIR_FILTER_OPTIONS = {
-    'OFF': BME280IIRFilter.BME280_IIR_FILTER_OFF,
-    '2X': BME280IIRFilter.BME280_IIR_FILTER_2X,
-    '4X': BME280IIRFilter.BME280_IIR_FILTER_4X,
-    '8X': BME280IIRFilter.BME280_IIR_FILTER_8X,
-    '16X': BME280IIRFilter.BME280_IIR_FILTER_16X,
+    "OFF": BME280IIRFilter.BME280_IIR_FILTER_OFF,
+    "2X": BME280IIRFilter.BME280_IIR_FILTER_2X,
+    "4X": BME280IIRFilter.BME280_IIR_FILTER_4X,
+    "8X": BME280IIRFilter.BME280_IIR_FILTER_8X,
+    "16X": BME280IIRFilter.BME280_IIR_FILTER_16X,
 }
 
-BME280Component = bme280_ns.class_('BME280Component', cg.PollingComponent, i2c.I2CDevice)
+BME280Component = bme280_ns.class_(
+    "BME280Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(BME280Component),
-    cv.Optional(CONF_TEMPERATURE):
-        sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_PRESSURE):
-        sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_HUMIDITY):
-        sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BME280Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_IIR_FILTER, default="OFF"): cv.enum(
+                IIR_FILTER_OPTIONS, upper=True
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x77))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
         conf = config[CONF_TEMPERATURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_temperature_sensor(sens))
         cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_PRESSURE in config:
         conf = config[CONF_PRESSURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_pressure_sensor(sens))
         cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_HUMIDITY in config:
         conf = config[CONF_HUMIDITY]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_humidity_sensor(sens))
         cg.add(var.set_humidity_oversampling(conf[CONF_OVERSAMPLING]))
 

esphome/components/bme680/bme680.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bme680 {
 
-static const char *TAG = "bme680.sensor";
+static const char *const TAG = "bme680.sensor";
 
 static const uint8_t BME680_REGISTER_COEFF1 = 0x89;
 static const uint8_t BME680_REGISTER_COEFF2 = 0xE1;

esphome/components/bme680/sensor.py

@@ -2,92 +2,155 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import core
 from esphome.components import i2c, sensor
-from esphome.const import CONF_DURATION, CONF_GAS_RESISTANCE, CONF_HEATER, \
-    CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_OVERSAMPLING, CONF_PRESSURE, \
-    CONF_TEMPERATURE, UNIT_OHM, ICON_GAS_CYLINDER, UNIT_CELSIUS, \
-    ICON_THERMOMETER, UNIT_HECTOPASCAL, ICON_GAUGE, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.const import (
+    CONF_DURATION,
+    CONF_GAS_RESISTANCE,
+    CONF_HEATER,
+    CONF_HUMIDITY,
+    CONF_ID,
+    CONF_IIR_FILTER,
+    CONF_OVERSAMPLING,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_OHM,
+    ICON_GAS_CYLINDER,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    UNIT_PERCENT,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-bme680_ns = cg.esphome_ns.namespace('bme680')
-BME680Oversampling = bme680_ns.enum('BME680Oversampling')
+bme680_ns = cg.esphome_ns.namespace("bme680")
+BME680Oversampling = bme680_ns.enum("BME680Oversampling")
 OVERSAMPLING_OPTIONS = {
-    'NONE': BME680Oversampling.BME680_OVERSAMPLING_NONE,
-    '1X': BME680Oversampling.BME680_OVERSAMPLING_1X,
-    '2X': BME680Oversampling.BME680_OVERSAMPLING_2X,
-    '4X': BME680Oversampling.BME680_OVERSAMPLING_4X,
-    '8X': BME680Oversampling.BME680_OVERSAMPLING_8X,
-    '16X': BME680Oversampling.BME680_OVERSAMPLING_16X,
+    "NONE": BME680Oversampling.BME680_OVERSAMPLING_NONE,
+    "1X": BME680Oversampling.BME680_OVERSAMPLING_1X,
+    "2X": BME680Oversampling.BME680_OVERSAMPLING_2X,
+    "4X": BME680Oversampling.BME680_OVERSAMPLING_4X,
+    "8X": BME680Oversampling.BME680_OVERSAMPLING_8X,
+    "16X": BME680Oversampling.BME680_OVERSAMPLING_16X,
 }
 
-BME680IIRFilter = bme680_ns.enum('BME680IIRFilter')
+BME680IIRFilter = bme680_ns.enum("BME680IIRFilter")
 IIR_FILTER_OPTIONS = {
-    'OFF': BME680IIRFilter.BME680_IIR_FILTER_OFF,
-    '1X': BME680IIRFilter.BME680_IIR_FILTER_1X,
-    '3X': BME680IIRFilter.BME680_IIR_FILTER_3X,
-    '7X': BME680IIRFilter.BME680_IIR_FILTER_7X,
-    '15X': BME680IIRFilter.BME680_IIR_FILTER_15X,
-    '31X': BME680IIRFilter.BME680_IIR_FILTER_31X,
-    '63X': BME680IIRFilter.BME680_IIR_FILTER_63X,
-    '127X': BME680IIRFilter.BME680_IIR_FILTER_127X,
+    "OFF": BME680IIRFilter.BME680_IIR_FILTER_OFF,
+    "1X": BME680IIRFilter.BME680_IIR_FILTER_1X,
+    "3X": BME680IIRFilter.BME680_IIR_FILTER_3X,
+    "7X": BME680IIRFilter.BME680_IIR_FILTER_7X,
+    "15X": BME680IIRFilter.BME680_IIR_FILTER_15X,
+    "31X": BME680IIRFilter.BME680_IIR_FILTER_31X,
+    "63X": BME680IIRFilter.BME680_IIR_FILTER_63X,
+    "127X": BME680IIRFilter.BME680_IIR_FILTER_127X,
 }
 
-BME680Component = bme680_ns.class_('BME680Component', cg.PollingComponent, i2c.I2CDevice)
+BME680Component = bme680_ns.class_(
+    "BME680Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(BME680Component),
-    cv.Optional(CONF_TEMPERATURE):
-        sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_PRESSURE):
-        sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_HUMIDITY):
-        sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({
-            cv.Optional(CONF_OVERSAMPLING, default='16X'):
-                cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-        }),
-    cv.Optional(CONF_GAS_RESISTANCE):
-        sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 1),
-    cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
-    cv.Optional(CONF_HEATER): cv.Any(None, cv.All(cv.Schema({
-        cv.Optional(CONF_TEMPERATURE, default=320): cv.int_range(min=200, max=400),
-        cv.Optional(CONF_DURATION, default='150ms'): cv.All(
-            cv.positive_time_period_milliseconds, cv.Range(max=core.TimePeriod(milliseconds=4032)))
-    }), cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION))),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x76))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BME680Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_GAS_RESISTANCE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_OHM,
+                icon=ICON_GAS_CYLINDER,
+                accuracy_decimals=1,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_IIR_FILTER, default="OFF"): cv.enum(
+                IIR_FILTER_OPTIONS, upper=True
+            ),
+            cv.Optional(CONF_HEATER): cv.Any(
+                None,
+                cv.All(
+                    cv.Schema(
+                        {
+                            cv.Optional(CONF_TEMPERATURE, default=320): cv.int_range(
+                                min=200, max=400
+                            ),
+                            cv.Optional(CONF_DURATION, default="150ms"): cv.All(
+                                cv.positive_time_period_milliseconds,
+                                cv.Range(max=core.TimePeriod(milliseconds=4032)),
+                            ),
+                        }
+                    ),
+                    cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION),
+                ),
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x76))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
         conf = config[CONF_TEMPERATURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_temperature_sensor(sens))
         cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_PRESSURE in config:
         conf = config[CONF_PRESSURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_pressure_sensor(sens))
         cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_HUMIDITY in config:
         conf = config[CONF_HUMIDITY]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_humidity_sensor(sens))
         cg.add(var.set_humidity_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_GAS_RESISTANCE in config:
         conf = config[CONF_GAS_RESISTANCE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_gas_resistance_sensor(sens))
 
     cg.add(var.set_iir_filter(IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]))

esphome/components/bme680_bsec/__init__.py

@@ -0,0 +1,64 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@trvrnrth"]
+DEPENDENCIES = ["i2c"]
+AUTO_LOAD = ["sensor", "text_sensor"]
+
+CONF_BME680_BSEC_ID = "bme680_bsec_id"
+CONF_TEMPERATURE_OFFSET = "temperature_offset"
+CONF_IAQ_MODE = "iaq_mode"
+CONF_SAMPLE_RATE = "sample_rate"
+CONF_STATE_SAVE_INTERVAL = "state_save_interval"
+
+bme680_bsec_ns = cg.esphome_ns.namespace("bme680_bsec")
+
+IAQMode = bme680_bsec_ns.enum("IAQMode")
+IAQ_MODE_OPTIONS = {
+    "STATIC": IAQMode.IAQ_MODE_STATIC,
+    "MOBILE": IAQMode.IAQ_MODE_MOBILE,
+}
+
+SampleRate = bme680_bsec_ns.enum("SampleRate")
+SAMPLE_RATE_OPTIONS = {
+    "LP": SampleRate.SAMPLE_RATE_LP,
+    "ULP": SampleRate.SAMPLE_RATE_ULP,
+}
+
+BME680BSECComponent = bme680_bsec_ns.class_(
+    "BME680BSECComponent", cg.Component, i2c.I2CDevice
+)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(BME680BSECComponent),
+        cv.Optional(CONF_TEMPERATURE_OFFSET, default=0): cv.temperature,
+        cv.Optional(CONF_IAQ_MODE, default="STATIC"): cv.enum(
+            IAQ_MODE_OPTIONS, upper=True
+        ),
+        cv.Optional(CONF_SAMPLE_RATE, default="LP"): cv.enum(
+            SAMPLE_RATE_OPTIONS, upper=True
+        ),
+        cv.Optional(
+            CONF_STATE_SAVE_INTERVAL, default="6hours"
+        ): cv.positive_time_period_minutes,
+    }
+).extend(i2c.i2c_device_schema(0x76))
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    cg.add(var.set_temperature_offset(config[CONF_TEMPERATURE_OFFSET]))
+    cg.add(var.set_iaq_mode(config[CONF_IAQ_MODE]))
+    cg.add(var.set_sample_rate(config[CONF_SAMPLE_RATE]))
+    cg.add(
+        var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL].total_milliseconds)
+    )
+
+    cg.add_define("USE_BSEC")
+    cg.add_library("BSEC Software Library", "1.6.1480")

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -0,0 +1,426 @@
+#include "bme680_bsec.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include <string>
+
+namespace esphome {
+namespace bme680_bsec {
+#ifdef USE_BSEC
+static const char *const TAG = "bme680_bsec.sensor";
+
+static const std::string IAQ_ACCURACY_STATES[4] = {"Stabilizing", "Uncertain", "Calibrating", "Calibrated"};
+
+BME680BSECComponent *BME680BSECComponent::instance;
+
+void BME680BSECComponent::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up BME680 via BSEC...");
+  BME680BSECComponent::instance = this;
+
+  this->bsec_status_ = bsec_init();
+  if (this->bsec_status_ != BSEC_OK) {
+    this->mark_failed();
+    return;
+  }
+
+  this->bme680_.dev_id = this->address_;
+  this->bme680_.intf = BME680_I2C_INTF;
+  this->bme680_.read = BME680BSECComponent::read_bytes_wrapper;
+  this->bme680_.write = BME680BSECComponent::write_bytes_wrapper;
+  this->bme680_.delay_ms = BME680BSECComponent::delay_ms;
+  this->bme680_.amb_temp = 25;
+
+  this->bme680_status_ = bme680_init(&this->bme680_);
+  if (this->bme680_status_ != BME680_OK) {
+    this->mark_failed();
+    return;
+  }
+
+  if (this->sample_rate_ == SAMPLE_RATE_ULP) {
+    const uint8_t bsec_config[] = {
+#include "config/generic_33v_300s_28d/bsec_iaq.txt"
+    };
+    this->set_config_(bsec_config);
+  } else {
+    const uint8_t bsec_config[] = {
+#include "config/generic_33v_3s_28d/bsec_iaq.txt"
+    };
+    this->set_config_(bsec_config);
+  }
+  this->update_subscription_();
+  if (this->bsec_status_ != BSEC_OK) {
+    this->mark_failed();
+    return;
+  }
+
+  this->load_state_();
+}
+
+void BME680BSECComponent::set_config_(const uint8_t *config) {
+  uint8_t work_buffer[BSEC_MAX_WORKBUFFER_SIZE];
+  this->bsec_status_ = bsec_set_configuration(config, BSEC_MAX_PROPERTY_BLOB_SIZE, work_buffer, sizeof(work_buffer));
+}
+
+float BME680BSECComponent::calc_sensor_sample_rate_(SampleRate sample_rate) {
+  if (sample_rate == SAMPLE_RATE_DEFAULT) {
+    sample_rate = this->sample_rate_;
+  }
+  return sample_rate == SAMPLE_RATE_ULP ? BSEC_SAMPLE_RATE_ULP : BSEC_SAMPLE_RATE_LP;
+}
+
+void BME680BSECComponent::update_subscription_() {
+  bsec_sensor_configuration_t virtual_sensors[BSEC_NUMBER_OUTPUTS];
+  int num_virtual_sensors = 0;
+
+  if (this->iaq_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id =
+        this->iaq_mode_ == IAQ_MODE_STATIC ? BSEC_OUTPUT_STATIC_IAQ : BSEC_OUTPUT_IAQ;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(SAMPLE_RATE_DEFAULT);
+    num_virtual_sensors++;
+  }
+
+  if (this->co2_equivalent_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_CO2_EQUIVALENT;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(SAMPLE_RATE_DEFAULT);
+    num_virtual_sensors++;
+  }
+
+  if (this->breath_voc_equivalent_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_BREATH_VOC_EQUIVALENT;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(SAMPLE_RATE_DEFAULT);
+    num_virtual_sensors++;
+  }
+
+  if (this->pressure_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_RAW_PRESSURE;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(this->pressure_sample_rate_);
+    num_virtual_sensors++;
+  }
+
+  if (this->gas_resistance_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_RAW_GAS;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(SAMPLE_RATE_DEFAULT);
+    num_virtual_sensors++;
+  }
+
+  if (this->temperature_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(this->temperature_sample_rate_);
+    num_virtual_sensors++;
+  }
+
+  if (this->humidity_sensor_) {
+    virtual_sensors[num_virtual_sensors].sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY;
+    virtual_sensors[num_virtual_sensors].sample_rate = this->calc_sensor_sample_rate_(this->humidity_sample_rate_);
+    num_virtual_sensors++;
+  }
+
+  bsec_sensor_configuration_t sensor_settings[BSEC_MAX_PHYSICAL_SENSOR];
+  uint8_t num_sensor_settings = BSEC_MAX_PHYSICAL_SENSOR;
+  this->bsec_status_ =
+      bsec_update_subscription(virtual_sensors, num_virtual_sensors, sensor_settings, &num_sensor_settings);
+}
+
+void BME680BSECComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "BME680 via BSEC:");
+
+  bsec_version_t version;
+  bsec_get_version(&version);
+  ESP_LOGCONFIG(TAG, "  BSEC Version: %d.%d.%d.%d", version.major, version.minor, version.major_bugfix,
+                version.minor_bugfix);
+
+  LOG_I2C_DEVICE(this);
+
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication failed (BSEC Status: %d, BME680 Status: %d)", this->bsec_status_,
+             this->bme680_status_);
+  }
+
+  ESP_LOGCONFIG(TAG, "  Temperature Offset: %.2f", this->temperature_offset_);
+  ESP_LOGCONFIG(TAG, "  IAQ Mode: %s", this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile");
+  ESP_LOGCONFIG(TAG, "  Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_));
+  ESP_LOGCONFIG(TAG, "  State Save Interval: %ims", this->state_save_interval_ms_);
+
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  ESP_LOGCONFIG(TAG, "    Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->temperature_sample_rate_));
+  LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
+  ESP_LOGCONFIG(TAG, "    Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->pressure_sample_rate_));
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+  ESP_LOGCONFIG(TAG, "    Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->humidity_sample_rate_));
+  LOG_SENSOR("  ", "Gas Resistance", this->gas_resistance_sensor_);
+  LOG_SENSOR("  ", "IAQ", this->iaq_sensor_);
+  LOG_SENSOR("  ", "Numeric IAQ Accuracy", this->iaq_accuracy_sensor_);
+  LOG_TEXT_SENSOR("  ", "IAQ Accuracy", this->iaq_accuracy_text_sensor_);
+  LOG_SENSOR("  ", "CO2 Equivalent", this->co2_equivalent_sensor_);
+  LOG_SENSOR("  ", "Breath VOC Equivalent", this->breath_voc_equivalent_sensor_);
+}
+
+float BME680BSECComponent::get_setup_priority() const { return setup_priority::DATA; }
+
+void BME680BSECComponent::loop() {
+  this->run_();
+
+  if (this->bsec_status_ < BSEC_OK || this->bme680_status_ < BME680_OK) {
+    this->status_set_error();
+  } else {
+    this->status_clear_error();
+  }
+  if (this->bsec_status_ > BSEC_OK || this->bme680_status_ > BME680_OK) {
+    this->status_set_warning();
+  } else {
+    this->status_clear_warning();
+  }
+}
+
+void BME680BSECComponent::run_() {
+  int64_t curr_time_ns = this->get_time_ns_();
+  if (curr_time_ns < this->next_call_ns_) {
+    return;
+  }
+
+  ESP_LOGV(TAG, "Performing sensor run");
+
+  bsec_bme_settings_t bme680_settings;
+  this->bsec_status_ = bsec_sensor_control(curr_time_ns, &bme680_settings);
+  if (this->bsec_status_ < BSEC_OK) {
+    ESP_LOGW(TAG, "Failed to fetch sensor control settings (BSEC Error Code %d)", this->bsec_status_);
+    return;
+  }
+  this->next_call_ns_ = bme680_settings.next_call;
+
+  if (bme680_settings.trigger_measurement) {
+    this->bme680_.tph_sett.os_temp = bme680_settings.temperature_oversampling;
+    this->bme680_.tph_sett.os_pres = bme680_settings.pressure_oversampling;
+    this->bme680_.tph_sett.os_hum = bme680_settings.humidity_oversampling;
+    this->bme680_.gas_sett.run_gas = bme680_settings.run_gas;
+    this->bme680_.gas_sett.heatr_temp = bme680_settings.heater_temperature;
+    this->bme680_.gas_sett.heatr_dur = bme680_settings.heating_duration;
+    this->bme680_.power_mode = BME680_FORCED_MODE;
+    uint16_t desired_settings = BME680_OST_SEL | BME680_OSP_SEL | BME680_OSH_SEL | BME680_GAS_SENSOR_SEL;
+    this->bme680_status_ = bme680_set_sensor_settings(desired_settings, &this->bme680_);
+    if (this->bme680_status_ != BME680_OK) {
+      ESP_LOGW(TAG, "Failed to set sensor settings (BME680 Error Code %d)", this->bme680_status_);
+      return;
+    }
+
+    this->bme680_status_ = bme680_set_sensor_mode(&this->bme680_);
+    if (this->bme680_status_ != BME680_OK) {
+      ESP_LOGW(TAG, "Failed to set sensor mode (BME680 Error Code %d)", this->bme680_status_);
+      return;
+    }
+
+    uint16_t meas_dur = 0;
+    bme680_get_profile_dur(&meas_dur, &this->bme680_);
+    ESP_LOGV(TAG, "Queueing read in %ums", meas_dur);
+    this->set_timeout("read", meas_dur,
+                      [this, curr_time_ns, bme680_settings]() { this->read_(curr_time_ns, bme680_settings); });
+  } else {
+    ESP_LOGV(TAG, "Measurement not required");
+    this->read_(curr_time_ns, bme680_settings);
+  }
+}
+
+void BME680BSECComponent::read_(int64_t trigger_time_ns, bsec_bme_settings_t bme680_settings) {
+  ESP_LOGV(TAG, "Reading data");
+
+  if (bme680_settings.trigger_measurement) {
+    while (this->bme680_.power_mode != BME680_SLEEP_MODE) {
+      this->bme680_status_ = bme680_get_sensor_mode(&this->bme680_);
+      if (this->bme680_status_ != BME680_OK) {
+        ESP_LOGW(TAG, "Failed to get sensor mode (BME680 Error Code %d)", this->bme680_status_);
+      }
+    }
+  }
+
+  if (!bme680_settings.process_data) {
+    ESP_LOGV(TAG, "Data processing not required");
+    return;
+  }
+
+  struct bme680_field_data data;
+  this->bme680_status_ = bme680_get_sensor_data(&data, &this->bme680_);
+
+  if (this->bme680_status_ != BME680_OK) {
+    ESP_LOGW(TAG, "Failed to get sensor data (BME680 Error Code %d)", this->bme680_status_);
+    return;
+  }
+  if (!(data.status & BME680_NEW_DATA_MSK)) {
+    ESP_LOGD(TAG, "BME680 did not report new data");
+    return;
+  }
+
+  bsec_input_t inputs[BSEC_MAX_PHYSICAL_SENSOR];  // Temperature, Pressure, Humidity & Gas Resistance
+  uint8_t num_inputs = 0;
+
+  if (bme680_settings.process_data & BSEC_PROCESS_TEMPERATURE) {
+    inputs[num_inputs].sensor_id = BSEC_INPUT_TEMPERATURE;
+    inputs[num_inputs].signal = data.temperature / 100.0f;
+    inputs[num_inputs].time_stamp = trigger_time_ns;
+    num_inputs++;
+
+    // Temperature offset from the real temperature due to external heat sources
+    inputs[num_inputs].sensor_id = BSEC_INPUT_HEATSOURCE;
+    inputs[num_inputs].signal = this->temperature_offset_;
+    inputs[num_inputs].time_stamp = trigger_time_ns;
+    num_inputs++;
+  }
+  if (bme680_settings.process_data & BSEC_PROCESS_HUMIDITY) {
+    inputs[num_inputs].sensor_id = BSEC_INPUT_HUMIDITY;
+    inputs[num_inputs].signal = data.humidity / 1000.0f;
+    inputs[num_inputs].time_stamp = trigger_time_ns;
+    num_inputs++;
+  }
+  if (bme680_settings.process_data & BSEC_PROCESS_PRESSURE) {
+    inputs[num_inputs].sensor_id = BSEC_INPUT_PRESSURE;
+    inputs[num_inputs].signal = data.pressure;
+    inputs[num_inputs].time_stamp = trigger_time_ns;
+    num_inputs++;
+  }
+  if (bme680_settings.process_data & BSEC_PROCESS_GAS) {
+    if (data.status & BME680_GASM_VALID_MSK) {
+      inputs[num_inputs].sensor_id = BSEC_INPUT_GASRESISTOR;
+      inputs[num_inputs].signal = data.gas_resistance;
+      inputs[num_inputs].time_stamp = trigger_time_ns;
+      num_inputs++;
+    } else {
+      ESP_LOGD(TAG, "BME680 did not report gas data");
+    }
+  }
+  if (num_inputs < 1) {
+    ESP_LOGD(TAG, "No signal inputs available for BSEC");
+    return;
+  }
+
+  bsec_output_t outputs[BSEC_NUMBER_OUTPUTS];
+  uint8_t num_outputs = BSEC_NUMBER_OUTPUTS;
+  this->bsec_status_ = bsec_do_steps(inputs, num_inputs, outputs, &num_outputs);
+  if (this->bsec_status_ != BSEC_OK) {
+    ESP_LOGW(TAG, "BSEC failed to process signals (BSEC Error Code %d)", this->bsec_status_);
+    return;
+  }
+  if (num_outputs < 1) {
+    ESP_LOGD(TAG, "No signal outputs provided by BSEC");
+    return;
+  }
+
+  this->publish_(outputs, num_outputs);
+}
+
+void BME680BSECComponent::publish_(const bsec_output_t *outputs, uint8_t num_outputs) {
+  ESP_LOGV(TAG, "Publishing sensor states");
+  for (uint8_t i = 0; i < num_outputs; i++) {
+    switch (outputs[i].sensor_id) {
+      case BSEC_OUTPUT_IAQ:
+      case BSEC_OUTPUT_STATIC_IAQ:
+        uint8_t accuracy;
+        accuracy = outputs[i].accuracy;
+        this->publish_sensor_state_(this->iaq_sensor_, outputs[i].signal);
+        this->publish_sensor_state_(this->iaq_accuracy_text_sensor_, IAQ_ACCURACY_STATES[accuracy]);
+        this->publish_sensor_state_(this->iaq_accuracy_sensor_, accuracy, true);
+
+        // Queue up an opportunity to save state
+        this->defer("save_state", [this, accuracy]() { this->save_state_(accuracy); });
+        break;
+      case BSEC_OUTPUT_CO2_EQUIVALENT:
+        this->publish_sensor_state_(this->co2_equivalent_sensor_, outputs[i].signal);
+        break;
+      case BSEC_OUTPUT_BREATH_VOC_EQUIVALENT:
+        this->publish_sensor_state_(this->breath_voc_equivalent_sensor_, outputs[i].signal);
+        break;
+      case BSEC_OUTPUT_RAW_PRESSURE:
+        this->publish_sensor_state_(this->pressure_sensor_, outputs[i].signal / 100.0f);
+        break;
+      case BSEC_OUTPUT_RAW_GAS:
+        this->publish_sensor_state_(this->gas_resistance_sensor_, outputs[i].signal);
+        break;
+      case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE:
+        this->publish_sensor_state_(this->temperature_sensor_, outputs[i].signal);
+        break;
+      case BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY:
+        this->publish_sensor_state_(this->humidity_sensor_, outputs[i].signal);
+        break;
+    }
+  }
+}
+
+int64_t BME680BSECComponent::get_time_ns_() {
+  int64_t time_ms = millis();
+  if (this->last_time_ms_ > time_ms) {
+    this->millis_overflow_counter_++;
+  }
+  this->last_time_ms_ = time_ms;
+
+  return (time_ms + ((int64_t) this->millis_overflow_counter_ << 32)) * INT64_C(1000000);
+}
+
+void BME680BSECComponent::publish_sensor_state_(sensor::Sensor *sensor, float value, bool change_only) {
+  if (!sensor || (change_only && sensor->has_state() && sensor->state == value)) {
+    return;
+  }
+  sensor->publish_state(value);
+}
+
+void BME680BSECComponent::publish_sensor_state_(text_sensor::TextSensor *sensor, std::string value) {
+  if (!sensor || (sensor->has_state() && sensor->state == value)) {
+    return;
+  }
+  sensor->publish_state(value);
+}
+
+int8_t BME680BSECComponent::read_bytes_wrapper(uint8_t address, uint8_t a_register, uint8_t *data, uint16_t len) {
+  return BME680BSECComponent::instance->read_bytes(a_register, data, len) ? 0 : -1;
+}
+
+int8_t BME680BSECComponent::write_bytes_wrapper(uint8_t address, uint8_t a_register, uint8_t *data, uint16_t len) {
+  return BME680BSECComponent::instance->write_bytes(a_register, data, len) ? 0 : -1;
+}
+
+void BME680BSECComponent::delay_ms(uint32_t period) {
+  ESP_LOGV(TAG, "Delaying for %ums", period);
+  delay(period);
+}
+
+void BME680BSECComponent::load_state_() {
+  uint32_t hash = fnv1_hash("bme680_bsec_state_" + to_string(this->address_));
+  this->bsec_state_ = global_preferences.make_preference<uint8_t[BSEC_MAX_STATE_BLOB_SIZE]>(hash, true);
+
+  uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
+  if (this->bsec_state_.load(&state)) {
+    ESP_LOGV(TAG, "Loading state");
+    uint8_t work_buffer[BSEC_MAX_WORKBUFFER_SIZE];
+    this->bsec_status_ = bsec_set_state(state, BSEC_MAX_STATE_BLOB_SIZE, work_buffer, sizeof(work_buffer));
+    if (this->bsec_status_ != BSEC_OK) {
+      ESP_LOGW(TAG, "Failed to load state (BSEC Error Code %d)", this->bsec_status_);
+    }
+    ESP_LOGI(TAG, "Loaded state");
+  }
+}
+
+void BME680BSECComponent::save_state_(uint8_t accuracy) {
+  if (accuracy < 3 || (millis() - this->last_state_save_ms_ < this->state_save_interval_ms_)) {
+    return;
+  }
+
+  ESP_LOGV(TAG, "Saving state");
+
+  uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
+  uint8_t work_buffer[BSEC_MAX_STATE_BLOB_SIZE];
+  uint32_t num_serialized_state = BSEC_MAX_STATE_BLOB_SIZE;
+
+  this->bsec_status_ =
+      bsec_get_state(0, state, BSEC_MAX_STATE_BLOB_SIZE, work_buffer, BSEC_MAX_STATE_BLOB_SIZE, &num_serialized_state);
+  if (this->bsec_status_ != BSEC_OK) {
+    ESP_LOGW(TAG, "Failed fetch state for save (BSEC Error Code %d)", this->bsec_status_);
+    return;
+  }
+
+  if (!this->bsec_state_.save(&state)) {
+    ESP_LOGW(TAG, "Failed to save state");
+    return;
+  }
+  this->last_state_save_ms_ = millis();
+
+  ESP_LOGI(TAG, "Saved state");
+}
+#endif
+}  // namespace bme680_bsec
+}  // namespace esphome

esphome/components/bme680_bsec/bme680_bsec.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/preferences.h"
+#include <map>
+
+#ifdef USE_BSEC
+#include <bsec.h>
+#endif
+
+namespace esphome {
+namespace bme680_bsec {
+#ifdef USE_BSEC
+
+enum IAQMode {
+  IAQ_MODE_STATIC = 0,
+  IAQ_MODE_MOBILE = 1,
+};
+
+enum SampleRate {
+  SAMPLE_RATE_LP = 0,
+  SAMPLE_RATE_ULP = 1,
+  SAMPLE_RATE_DEFAULT = 2,
+};
+
+#define BME680_BSEC_SAMPLE_RATE_LOG(r) (r == SAMPLE_RATE_DEFAULT ? "Default" : (r == SAMPLE_RATE_ULP ? "ULP" : "LP"))
+
+class BME680BSECComponent : public Component, public i2c::I2CDevice {
+ public:
+  void set_temperature_offset(float offset) { this->temperature_offset_ = offset; }
+  void set_iaq_mode(IAQMode iaq_mode) { this->iaq_mode_ = iaq_mode; }
+  void set_state_save_interval(uint32_t interval) { this->state_save_interval_ms_ = interval; }
+
+  void set_sample_rate(SampleRate sample_rate) { this->sample_rate_ = sample_rate; }
+  void set_temperature_sample_rate(SampleRate sample_rate) { this->temperature_sample_rate_ = sample_rate; }
+  void set_pressure_sample_rate(SampleRate sample_rate) { this->pressure_sample_rate_ = sample_rate; }
+  void set_humidity_sample_rate(SampleRate sample_rate) { this->humidity_sample_rate_ = sample_rate; }
+
+  void set_temperature_sensor(sensor::Sensor *sensor) { this->temperature_sensor_ = sensor; }
+  void set_pressure_sensor(sensor::Sensor *sensor) { this->pressure_sensor_ = sensor; }
+  void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }
+  void set_gas_resistance_sensor(sensor::Sensor *sensor) { this->gas_resistance_sensor_ = sensor; }
+  void set_iaq_sensor(sensor::Sensor *sensor) { this->iaq_sensor_ = sensor; }
+  void set_iaq_accuracy_text_sensor(text_sensor::TextSensor *sensor) { this->iaq_accuracy_text_sensor_ = sensor; }
+  void set_iaq_accuracy_sensor(sensor::Sensor *sensor) { this->iaq_accuracy_sensor_ = sensor; }
+  void set_co2_equivalent_sensor(sensor::Sensor *sensor) { this->co2_equivalent_sensor_ = sensor; }
+  void set_breath_voc_equivalent_sensor(sensor::Sensor *sensor) { this->breath_voc_equivalent_sensor_ = sensor; }
+
+  static BME680BSECComponent *instance;
+  static int8_t read_bytes_wrapper(uint8_t address, uint8_t a_register, uint8_t *data, uint16_t len);
+  static int8_t write_bytes_wrapper(uint8_t address, uint8_t a_register, uint8_t *data, uint16_t len);
+  static void delay_ms(uint32_t period);
+
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void loop() override;
+
+ protected:
+  void set_config_(const uint8_t *config);
+  float calc_sensor_sample_rate_(SampleRate sample_rate);
+  void update_subscription_();
+
+  void run_();
+  void read_(int64_t trigger_time_ns, bsec_bme_settings_t bme680_settings);
+  void publish_(const bsec_output_t *outputs, uint8_t num_outputs);
+  int64_t get_time_ns_();
+
+  void publish_sensor_state_(sensor::Sensor *sensor, float value, bool change_only = false);
+  void publish_sensor_state_(text_sensor::TextSensor *sensor, std::string value);
+
+  void load_state_();
+  void save_state_(uint8_t accuracy);
+
+  struct bme680_dev bme680_;
+  bsec_library_return_t bsec_status_{BSEC_OK};
+  int8_t bme680_status_{BME680_OK};
+
+  int64_t last_time_ms_{0};
+  uint32_t millis_overflow_counter_{0};
+  int64_t next_call_ns_{0};
+
+  ESPPreferenceObject bsec_state_;
+  uint32_t state_save_interval_ms_{21600000};  // 6 hours - 4 times a day
+  uint32_t last_state_save_ms_ = 0;
+
+  float temperature_offset_{0};
+  IAQMode iaq_mode_{IAQ_MODE_STATIC};
+
+  SampleRate sample_rate_{SAMPLE_RATE_LP};  // Core/gas sample rate
+  SampleRate temperature_sample_rate_{SAMPLE_RATE_DEFAULT};
+  SampleRate pressure_sample_rate_{SAMPLE_RATE_DEFAULT};
+  SampleRate humidity_sample_rate_{SAMPLE_RATE_DEFAULT};
+
+  sensor::Sensor *temperature_sensor_;
+  sensor::Sensor *pressure_sensor_;
+  sensor::Sensor *humidity_sensor_;
+  sensor::Sensor *gas_resistance_sensor_;
+  sensor::Sensor *iaq_sensor_;
+  text_sensor::TextSensor *iaq_accuracy_text_sensor_;
+  sensor::Sensor *iaq_accuracy_sensor_;
+  sensor::Sensor *co2_equivalent_sensor_;
+  sensor::Sensor *breath_voc_equivalent_sensor_;
+};
+#endif
+}  // namespace bme680_bsec
+}  // namespace esphome

esphome/components/bme680_bsec/sensor.py

@@ -0,0 +1,126 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor
+from esphome.const import (
+    CONF_GAS_RESISTANCE,
+    CONF_HUMIDITY,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    UNIT_OHM,
+    UNIT_PARTS_PER_MILLION,
+    UNIT_PERCENT,
+    ICON_GAS_CYLINDER,
+    ICON_GAUGE,
+    ICON_THERMOMETER,
+    ICON_WATER_PERCENT,
+)
+from . import (
+    BME680BSECComponent,
+    CONF_BME680_BSEC_ID,
+    CONF_SAMPLE_RATE,
+    SAMPLE_RATE_OPTIONS,
+)
+
+DEPENDENCIES = ["bme680_bsec"]
+
+CONF_IAQ = "iaq"
+CONF_IAQ_ACCURACY = "iaq_accuracy"
+CONF_CO2_EQUIVALENT = "co2_equivalent"
+CONF_BREATH_VOC_EQUIVALENT = "breath_voc_equivalent"
+UNIT_IAQ = "IAQ"
+ICON_ACCURACY = "mdi:checkbox-marked-circle-outline"
+ICON_TEST_TUBE = "mdi:test-tube"
+
+TYPES = [
+    CONF_TEMPERATURE,
+    CONF_PRESSURE,
+    CONF_HUMIDITY,
+    CONF_GAS_RESISTANCE,
+    CONF_IAQ,
+    CONF_IAQ_ACCURACY,
+    CONF_CO2_EQUIVALENT,
+    CONF_BREATH_VOC_EQUIVALENT,
+]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_BME680_BSEC_ID): cv.use_id(BME680BSECComponent),
+        cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_CELSIUS,
+            icon=ICON_THERMOMETER,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_TEMPERATURE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ).extend(
+            {cv.Optional(CONF_SAMPLE_RATE): cv.enum(SAMPLE_RATE_OPTIONS, upper=True)}
+        ),
+        cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_HECTOPASCAL,
+            icon=ICON_GAUGE,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_PRESSURE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ).extend(
+            {cv.Optional(CONF_SAMPLE_RATE): cv.enum(SAMPLE_RATE_OPTIONS, upper=True)}
+        ),
+        cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            icon=ICON_WATER_PERCENT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_HUMIDITY,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ).extend(
+            {cv.Optional(CONF_SAMPLE_RATE): cv.enum(SAMPLE_RATE_OPTIONS, upper=True)}
+        ),
+        cv.Optional(CONF_GAS_RESISTANCE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_OHM,
+            icon=ICON_GAS_CYLINDER,
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_IAQ): sensor.sensor_schema(
+            unit_of_measurement=UNIT_IAQ,
+            icon=ICON_GAUGE,
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_IAQ_ACCURACY): sensor.sensor_schema(
+            icon=ICON_ACCURACY,
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_CO2_EQUIVALENT): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PARTS_PER_MILLION,
+            icon=ICON_TEST_TUBE,
+            accuracy_decimals=1,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_BREATH_VOC_EQUIVALENT): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PARTS_PER_MILLION,
+            icon=ICON_TEST_TUBE,
+            accuracy_decimals=1,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+    }
+)
+
+
+async def setup_conf(config, key, hub):
+    if key in config:
+        conf = config[key]
+        sens = await sensor.new_sensor(conf)
+        cg.add(getattr(hub, f"set_{key}_sensor")(sens))
+        if CONF_SAMPLE_RATE in conf:
+            cg.add(getattr(hub, f"set_{key}_sample_rate")(conf[CONF_SAMPLE_RATE]))
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_BME680_BSEC_ID])
+    for key in TYPES:
+        await setup_conf(config, key, hub)

esphome/components/bme680_bsec/text_sensor.py

@@ -0,0 +1,38 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import text_sensor
+from esphome.const import CONF_ID, CONF_ICON
+from . import BME680BSECComponent, CONF_BME680_BSEC_ID
+
+DEPENDENCIES = ["bme680_bsec"]
+
+CONF_IAQ_ACCURACY = "iaq_accuracy"
+ICON_ACCURACY = "mdi:checkbox-marked-circle-outline"
+
+TYPES = [CONF_IAQ_ACCURACY]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_BME680_BSEC_ID): cv.use_id(BME680BSECComponent),
+        cv.Optional(CONF_IAQ_ACCURACY): text_sensor.TEXT_SENSOR_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(text_sensor.TextSensor),
+                cv.Optional(CONF_ICON, default=ICON_ACCURACY): cv.icon,
+            }
+        ),
+    }
+)
+
+
+async def setup_conf(config, key, hub):
+    if key in config:
+        conf = config[key]
+        sens = cg.new_Pvariable(conf[CONF_ID])
+        await text_sensor.register_text_sensor(sens, conf)
+        cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_BME680_BSEC_ID])
+    for key in TYPES:
+        await setup_conf(config, key, hub)

esphome/components/bmp085/bmp085.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bmp085 {
 
-static const char *TAG = "bmp085.sensor";
+static const char *const TAG = "bmp085.sensor";
 
 static const uint8_t BMP085_ADDRESS = 0x77;
 static const uint8_t BMP085_REGISTER_AC1_H = 0xAA;

esphome/components/bmp085/sensor.py

@@ -1,32 +1,58 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_ID, CONF_PRESSURE, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL
+from esphome.const import (
+    CONF_ID,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-bmp085_ns = cg.esphome_ns.namespace('bmp085')
-BMP085Component = bmp085_ns.class_('BMP085Component', cg.PollingComponent, i2c.I2CDevice)
+bmp085_ns = cg.esphome_ns.namespace("bmp085")
+BMP085Component = bmp085_ns.class_(
+    "BMP085Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(BMP085Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1),
-    cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BMP085Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x77))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
         conf = config[CONF_TEMPERATURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_temperature(sens))
 
     if CONF_PRESSURE in config:
         conf = config[CONF_PRESSURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_pressure(sens))

esphome/components/bmp280/bmp280.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bmp280 {
 
-static const char *TAG = "bmp280.sensor";
+static const char *const TAG = "bmp280.sensor";
 
 static const uint8_t BMP280_REGISTER_STATUS = 0xF3;
 static const uint8_t BMP280_REGISTER_CONTROL = 0xF4;

esphome/components/bmp280/sensor.py

@@ -1,59 +1,96 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_ID, CONF_PRESSURE, CONF_TEMPERATURE, \
-    UNIT_CELSIUS, ICON_THERMOMETER, ICON_GAUGE, UNIT_HECTOPASCAL, \
-    CONF_IIR_FILTER, CONF_OVERSAMPLING
+from esphome.const import (
+    CONF_ID,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    CONF_IIR_FILTER,
+    CONF_OVERSAMPLING,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-bmp280_ns = cg.esphome_ns.namespace('bmp280')
-BMP280Oversampling = bmp280_ns.enum('BMP280Oversampling')
+bmp280_ns = cg.esphome_ns.namespace("bmp280")
+BMP280Oversampling = bmp280_ns.enum("BMP280Oversampling")
 OVERSAMPLING_OPTIONS = {
-    'NONE': BMP280Oversampling.BMP280_OVERSAMPLING_NONE,
-    '1X': BMP280Oversampling.BMP280_OVERSAMPLING_1X,
-    '2X': BMP280Oversampling.BMP280_OVERSAMPLING_2X,
-    '4X': BMP280Oversampling.BMP280_OVERSAMPLING_4X,
-    '8X': BMP280Oversampling.BMP280_OVERSAMPLING_8X,
-    '16X': BMP280Oversampling.BMP280_OVERSAMPLING_16X,
+    "NONE": BMP280Oversampling.BMP280_OVERSAMPLING_NONE,
+    "1X": BMP280Oversampling.BMP280_OVERSAMPLING_1X,
+    "2X": BMP280Oversampling.BMP280_OVERSAMPLING_2X,
+    "4X": BMP280Oversampling.BMP280_OVERSAMPLING_4X,
+    "8X": BMP280Oversampling.BMP280_OVERSAMPLING_8X,
+    "16X": BMP280Oversampling.BMP280_OVERSAMPLING_16X,
 }
 
-BMP280IIRFilter = bmp280_ns.enum('BMP280IIRFilter')
+BMP280IIRFilter = bmp280_ns.enum("BMP280IIRFilter")
 IIR_FILTER_OPTIONS = {
-    'OFF': BMP280IIRFilter.BMP280_IIR_FILTER_OFF,
-    '2X': BMP280IIRFilter.BMP280_IIR_FILTER_2X,
-    '4X': BMP280IIRFilter.BMP280_IIR_FILTER_4X,
-    '8X': BMP280IIRFilter.BMP280_IIR_FILTER_8X,
-    '16X': BMP280IIRFilter.BMP280_IIR_FILTER_16X,
+    "OFF": BMP280IIRFilter.BMP280_IIR_FILTER_OFF,
+    "2X": BMP280IIRFilter.BMP280_IIR_FILTER_2X,
+    "4X": BMP280IIRFilter.BMP280_IIR_FILTER_4X,
+    "8X": BMP280IIRFilter.BMP280_IIR_FILTER_8X,
+    "16X": BMP280IIRFilter.BMP280_IIR_FILTER_16X,
 }
 
-BMP280Component = bmp280_ns.class_('BMP280Component', cg.PollingComponent, i2c.I2CDevice)
+BMP280Component = bmp280_ns.class_(
+    "BMP280Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(BMP280Component),
-    cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
-        cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-    }),
-    cv.Optional(CONF_PRESSURE): sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
-        cv.Optional(CONF_OVERSAMPLING, default='16X'): cv.enum(OVERSAMPLING_OPTIONS, upper=True),
-    }),
-    cv.Optional(CONF_IIR_FILTER, default='OFF'): cv.enum(IIR_FILTER_OPTIONS, upper=True),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x77))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BMP280Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ).extend(
+                {
+                    cv.Optional(CONF_OVERSAMPLING, default="16X"): cv.enum(
+                        OVERSAMPLING_OPTIONS, upper=True
+                    ),
+                }
+            ),
+            cv.Optional(CONF_IIR_FILTER, default="OFF"): cv.enum(
+                IIR_FILTER_OPTIONS, upper=True
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x77))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
     if CONF_TEMPERATURE in config:
         conf = config[CONF_TEMPERATURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_temperature_sensor(sens))
         cg.add(var.set_temperature_oversampling(conf[CONF_OVERSAMPLING]))
 
     if CONF_PRESSURE in config:
         conf = config[CONF_PRESSURE]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(var.set_pressure_sensor(sens))
         cg.add(var.set_pressure_oversampling(conf[CONF_OVERSAMPLING]))

esphome/components/canbus/__init__.py

@@ -0,0 +1,145 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.core import CORE
+from esphome.const import CONF_ID, CONF_TRIGGER_ID, CONF_DATA
+
+CODEOWNERS = ["@mvturnho", "@danielschramm"]
+IS_PLATFORM_COMPONENT = True
+
+CONF_CAN_ID = "can_id"
+CONF_USE_EXTENDED_ID = "use_extended_id"
+CONF_CANBUS_ID = "canbus_id"
+CONF_BIT_RATE = "bit_rate"
+CONF_ON_FRAME = "on_frame"
+
+
+def validate_id(id_value, id_ext):
+    if not id_ext:
+        if id_value > 0x7FF:
+            raise cv.Invalid("Standard IDs must be 11 Bit (0x000-0x7ff / 0-2047)")
+
+
+def validate_raw_data(value):
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise cv.Invalid(
+        "data must either be a string wrapped in quotes or a list of bytes"
+    )
+
+
+canbus_ns = cg.esphome_ns.namespace("canbus")
+CanbusComponent = canbus_ns.class_("CanbusComponent", cg.Component)
+CanbusTrigger = canbus_ns.class_(
+    "CanbusTrigger",
+    automation.Trigger.template(cg.std_vector.template(cg.uint8)),
+    cg.Component,
+)
+CanSpeed = canbus_ns.enum("CAN_SPEED")
+
+CAN_SPEEDS = {
+    "5KBPS": CanSpeed.CAN_5KBPS,
+    "10KBPS": CanSpeed.CAN_10KBPS,
+    "20KBPS": CanSpeed.CAN_20KBPS,
+    "31K25BPS": CanSpeed.CAN_31K25BPS,
+    "33KBPS": CanSpeed.CAN_33KBPS,
+    "40KBPS": CanSpeed.CAN_40KBPS,
+    "50KBPS": CanSpeed.CAN_50KBPS,
+    "80KBPS": CanSpeed.CAN_80KBPS,
+    "83K3BPS": CanSpeed.CAN_83K3BPS,
+    "95KBPS": CanSpeed.CAN_95KBPS,
+    "100KBPS": CanSpeed.CAN_100KBPS,
+    "125KBPS": CanSpeed.CAN_125KBPS,
+    "200KBPS": CanSpeed.CAN_200KBPS,
+    "250KBPS": CanSpeed.CAN_250KBPS,
+    "500KBPS": CanSpeed.CAN_500KBPS,
+    "1000KBPS": CanSpeed.CAN_1000KBPS,
+}
+
+CANBUS_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(CanbusComponent),
+        cv.Required(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
+        cv.Optional(CONF_BIT_RATE, default="125KBPS"): cv.enum(CAN_SPEEDS, upper=True),
+        cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
+        cv.Optional(CONF_ON_FRAME): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger),
+                cv.GenerateID(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
+                cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
+                cv.Optional(CONF_ON_FRAME): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger),
+                        cv.GenerateID(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
+                        cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
+                    }
+                ),
+            }
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def setup_canbus_core_(var, config):
+    validate_id(config[CONF_CAN_ID], config[CONF_USE_EXTENDED_ID])
+    await cg.register_component(var, config)
+    cg.add(var.set_can_id([config[CONF_CAN_ID]]))
+    cg.add(var.set_use_extended_id([config[CONF_USE_EXTENDED_ID]]))
+    cg.add(var.set_bitrate(CAN_SPEEDS[config[CONF_BIT_RATE]]))
+
+    for conf in config.get(CONF_ON_FRAME, []):
+        can_id = conf[CONF_CAN_ID]
+        ext_id = conf[CONF_USE_EXTENDED_ID]
+        validate_id(can_id, ext_id)
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var, can_id, ext_id)
+        await cg.register_component(trigger, conf)
+        await automation.build_automation(
+            trigger, [(cg.std_vector.template(cg.uint8), "x")], conf
+        )
+
+
+async def register_canbus(var, config):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.new_Pvariable(config[CONF_ID], var)
+    await setup_canbus_core_(var, config)
+
+
+# Actions
+@automation.register_action(
+    "canbus.send",
+    canbus_ns.class_("CanbusSendAction", automation.Action),
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(CONF_CANBUS_ID): cv.use_id(CanbusComponent),
+            cv.Optional(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
+            cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
+            cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+        },
+        key=CONF_DATA,
+    ),
+)
+async def canbus_action_to_code(config, action_id, template_arg, args):
+    validate_id(config[CONF_CAN_ID], config[CONF_USE_EXTENDED_ID])
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_CANBUS_ID])
+
+    if CONF_CAN_ID in config:
+        can_id = await cg.templatable(config[CONF_CAN_ID], args, cg.uint32)
+        cg.add(var.set_can_id(can_id))
+
+    use_extended_id = await cg.templatable(
+        config[CONF_USE_EXTENDED_ID], args, cg.uint32
+    )
+    cg.add(var.set_use_extended_id(use_extended_id))
+
+    data = config[CONF_DATA]
+    if isinstance(data, bytes):
+        data = [int(x) for x in data]
+    if cg.is_template(data):
+        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
+        cg.add(var.set_data_template(templ))
+    else:
+        cg.add(var.set_data_static(data))
+    return var

esphome/components/canbus/canbus.cpp

@@ -0,0 +1,87 @@
+#include "canbus.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace canbus {
+
+static const char *const TAG = "canbus";
+
+void Canbus::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Canbus...");
+  if (!this->setup_internal()) {
+    ESP_LOGE(TAG, "setup error!");
+    this->mark_failed();
+  }
+}
+
+void Canbus::dump_config() {
+  if (this->use_extended_id_) {
+    ESP_LOGCONFIG(TAG, "config extended id=0x%08x", this->can_id_);
+  } else {
+    ESP_LOGCONFIG(TAG, "config standard id=0x%03x", this->can_id_);
+  }
+}
+
+void Canbus::send_data(uint32_t can_id, bool use_extended_id, const std::vector<uint8_t> &data) {
+  struct CanFrame can_message;
+
+  uint8_t size = static_cast<uint8_t>(data.size());
+  if (use_extended_id) {
+    ESP_LOGD(TAG, "send extended id=0x%08x size=%d", can_id, size);
+  } else {
+    ESP_LOGD(TAG, "send extended id=0x%03x size=%d", can_id, size);
+  }
+  if (size > CAN_MAX_DATA_LENGTH)
+    size = CAN_MAX_DATA_LENGTH;
+  can_message.can_data_length_code = size;
+  can_message.can_id = can_id;
+  can_message.use_extended_id = use_extended_id;
+
+  for (int i = 0; i < size; i++) {
+    can_message.data[i] = data[i];
+    ESP_LOGVV(TAG, "  data[%d]=%02x", i, can_message.data[i]);
+  }
+
+  this->send_message(&can_message);
+}
+
+void Canbus::add_trigger(CanbusTrigger *trigger) {
+  if (trigger->use_extended_id_) {
+    ESP_LOGVV(TAG, "add trigger for extended canid=0x%08x", trigger->can_id_);
+  } else {
+    ESP_LOGVV(TAG, "add trigger for std canid=0x%03x", trigger->can_id_);
+  }
+  this->triggers_.push_back(trigger);
+};
+
+void Canbus::loop() {
+  struct CanFrame can_message;
+  // readmessage
+  if (this->read_message(&can_message) == canbus::ERROR_OK) {
+    if (can_message.use_extended_id) {
+      ESP_LOGD(TAG, "received can message extended can_id=0x%x size=%d", can_message.can_id,
+               can_message.can_data_length_code);
+    } else {
+      ESP_LOGD(TAG, "received can message std can_id=0x%x size=%d", can_message.can_id,
+               can_message.can_data_length_code);
+    }
+
+    std::vector<uint8_t> data;
+
+    // show data received
+    for (int i = 0; i < can_message.can_data_length_code; i++) {
+      ESP_LOGV(TAG, "  can_message.data[%d]=%02x", i, can_message.data[i]);
+      data.push_back(can_message.data[i]);
+    }
+
+    // fire all triggers
+    for (auto trigger : this->triggers_) {
+      if ((trigger->can_id_ == can_message.can_id) && (trigger->use_extended_id_ == can_message.use_extended_id)) {
+        trigger->trigger(data);
+      }
+    }
+  }
+}
+
+}  // namespace canbus
+}  // namespace esphome

esphome/components/canbus/canbus.h

@@ -0,0 +1,134 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/optional.h"
+
+namespace esphome {
+namespace canbus {
+
+enum Error : uint8_t {
+  ERROR_OK = 0,
+  ERROR_FAIL = 1,
+  ERROR_ALLTXBUSY = 2,
+  ERROR_FAILINIT = 3,
+  ERROR_FAILTX = 4,
+  ERROR_NOMSG = 5
+};
+
+enum CanSpeed : uint8_t {
+  CAN_5KBPS,
+  CAN_10KBPS,
+  CAN_20KBPS,
+  CAN_31K25BPS,
+  CAN_33KBPS,
+  CAN_40KBPS,
+  CAN_50KBPS,
+  CAN_80KBPS,
+  CAN_83K3BPS,
+  CAN_95KBPS,
+  CAN_100KBPS,
+  CAN_125KBPS,
+  CAN_200KBPS,
+  CAN_250KBPS,
+  CAN_500KBPS,
+  CAN_1000KBPS
+};
+
+class CanbusTrigger;
+template<typename... Ts> class CanbusSendAction;
+
+/* CAN payload length definitions according to ISO 11898-1 */
+static const uint8_t CAN_MAX_DATA_LENGTH = 8;
+
+/*
+Can Frame describes a normative CAN Frame
+The RTR = Remote Transmission Request is implemented in every CAN controller but rarely used
+So currently the flag is passed to and from the hardware but currently ignored to the user application.
+*/
+struct CanFrame {
+  bool use_extended_id = false;
+  bool remote_transmission_request = false;
+  uint32_t can_id;              /* 29 or 11 bit CAN_ID  */
+  uint8_t can_data_length_code; /* frame payload length in byte (0 .. CAN_MAX_DATA_LENGTH) */
+  uint8_t data[CAN_MAX_DATA_LENGTH] __attribute__((aligned(8)));
+};
+
+class Canbus : public Component {
+ public:
+  Canbus(){};
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+  void loop() override;
+
+  void send_data(uint32_t can_id, bool use_extended_id, const std::vector<uint8_t> &data);
+  void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
+  void set_use_extended_id(bool use_extended_id) { this->use_extended_id_ = use_extended_id; }
+  void set_bitrate(CanSpeed bit_rate) { this->bit_rate_ = bit_rate; }
+
+  void add_trigger(CanbusTrigger *trigger);
+
+ protected:
+  template<typename... Ts> friend class CanbusSendAction;
+  std::vector<CanbusTrigger *> triggers_{};
+  uint32_t can_id_;
+  bool use_extended_id_;
+  CanSpeed bit_rate_;
+
+  virtual bool setup_internal();
+  virtual Error send_message(struct CanFrame *frame);
+  virtual Error read_message(struct CanFrame *frame);
+};
+
+template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public Parented<Canbus> {
+ public:
+  void set_data_template(const std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    this->static_ = false;
+  }
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = data;
+    this->static_ = true;
+  }
+
+  void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
+
+  void set_use_extended_id(bool use_extended_id) { this->use_extended_id_ = use_extended_id; }
+
+  void play(Ts... x) override {
+    auto can_id = this->can_id_.has_value() ? *this->can_id_ : this->parent_->can_id_;
+    auto use_extended_id =
+        this->use_extended_id_.has_value() ? *this->use_extended_id_ : this->parent_->use_extended_id_;
+    if (this->static_) {
+      this->parent_->send_data(can_id, use_extended_id, this->data_static_);
+    } else {
+      auto val = this->data_func_(x...);
+      this->parent_->send_data(can_id, use_extended_id, val);
+    }
+  }
+
+ protected:
+  optional<uint32_t> can_id_{};
+  optional<bool> use_extended_id_{};
+  bool static_{false};
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
+};
+
+class CanbusTrigger : public Trigger<std::vector<uint8_t>>, public Component {
+  friend class Canbus;
+
+ public:
+  explicit CanbusTrigger(Canbus *parent, const std::uint32_t can_id, const bool use_extended_id)
+      : parent_(parent), can_id_(can_id), use_extended_id_(use_extended_id){};
+  void setup() override { this->parent_->add_trigger(this); }
+
+ protected:
+  Canbus *parent_;
+  uint32_t can_id_;
+  bool use_extended_id_;
+};
+
+}  // namespace canbus
+}  // namespace esphome

esphome/components/captive_portal/__init__.py

@@ -5,23 +5,27 @@ from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.const import CONF_ID
 from esphome.core import coroutine_with_priority
 
-AUTO_LOAD = ['web_server_base']
-DEPENDENCIES = ['wifi']
-CODEOWNERS = ['@OttoWinter']
+AUTO_LOAD = ["web_server_base"]
+DEPENDENCIES = ["wifi"]
+CODEOWNERS = ["@OttoWinter"]
 
-captive_portal_ns = cg.esphome_ns.namespace('captive_portal')
-CaptivePortal = captive_portal_ns.class_('CaptivePortal', cg.Component)
+captive_portal_ns = cg.esphome_ns.namespace("captive_portal")
+CaptivePortal = captive_portal_ns.class_("CaptivePortal", cg.Component)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(CaptivePortal),
-    cv.GenerateID(CONF_WEB_SERVER_BASE_ID): cv.use_id(web_server_base.WebServerBase),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(CaptivePortal),
+        cv.GenerateID(CONF_WEB_SERVER_BASE_ID): cv.use_id(
+            web_server_base.WebServerBase
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
 @coroutine_with_priority(64.0)
-def to_code(config):
-    paren = yield cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])
+async def to_code(config):
+    paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])
 
     var = cg.new_Pvariable(config[CONF_ID], paren)
-    yield cg.register_component(var, config)
-    cg.add_define('USE_CAPTIVE_PORTAL')
+    await cg.register_component(var, config)
+    cg.add_define("USE_CAPTIVE_PORTAL")

esphome/components/captive_portal/captive_portal.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace captive_portal {
 
-static const char *TAG = "captive_portal";
+static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_index(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream("text/html");
@@ -64,32 +64,11 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   ESP_LOGI(TAG, "Captive Portal Requested WiFi Settings Change:");
   ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
-  this->override_sta_(ssid, psk);
+  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
   request->redirect("/?save=true");
 }
-void CaptivePortal::override_sta_(const std::string &ssid, const std::string &password) {
-  CaptivePortalSettings save{};
-  strcpy(save.ssid, ssid.c_str());
-  strcpy(save.password, password.c_str());
-  this->pref_.save(&save);
 
-  wifi::WiFiAP sta{};
-  sta.set_ssid(ssid);
-  sta.set_password(password);
-  wifi::global_wifi_component->set_sta(sta);
-}
-
-void CaptivePortal::setup() {
-  // Hash with compilation time
-  // This ensures the AP override is not applied for OTA
-  uint32_t hash = fnv1_hash(App.get_compilation_time());
-  this->pref_ = global_preferences.make_preference<CaptivePortalSettings>(hash, true);
-
-  CaptivePortalSettings save{};
-  if (this->pref_.load(&save)) {
-    this->override_sta_(save.ssid, save.password);
-  }
-}
+void CaptivePortal::setup() {}
 void CaptivePortal::start() {
   this->base_->init();
   if (!this->initialized_) {
@@ -168,7 +147,7 @@ float CaptivePortal::get_setup_priority() const {
 }
 void CaptivePortal::dump_config() { ESP_LOGCONFIG(TAG, "Captive Portal:"); }
 
-CaptivePortal *global_captive_portal = nullptr;
+CaptivePortal *global_captive_portal = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace captive_portal
 }  // namespace esphome

esphome/components/captive_portal/captive_portal.h

@@ -10,11 +10,6 @@ namespace esphome {
 
 namespace captive_portal {
 
-struct CaptivePortalSettings {
-  char ssid[33];
-  char password[65];
-} PACKED;  // NOLINT
-
 class CaptivePortal : public AsyncWebHandler, public Component {
  public:
   CaptivePortal(web_server_base::WebServerBase *base);
@@ -67,16 +62,13 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void handleRequest(AsyncWebServerRequest *req) override;
 
  protected:
-  void override_sta_(const std::string &ssid, const std::string &password);
-
   web_server_base::WebServerBase *base_;
   bool initialized_{false};
   bool active_{false};
-  ESPPreferenceObject pref_;
   DNSServer *dns_server_{nullptr};
 };
 
-extern CaptivePortal *global_captive_portal;
+extern CaptivePortal *global_captive_portal;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace captive_portal
 }  // namespace esphome

esphome/components/ccs811/ccs811.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace ccs811 {
 
-static const char *TAG = "ccs811";
+static const char *const TAG = "ccs811";
 
 // based on
 //  - https://cdn.sparkfun.com/datasheets/BreakoutBoards/CCS811_Programming_Guide.pdf
@@ -102,10 +102,14 @@ void CCS811Component::send_env_data_() {
   // temperature has a 25° offset to allow negative temperatures
   temperature += 25;
 
-  // only 0.5 fractions are supported (application note)
-  auto hum_value = static_cast<uint8_t>(roundf(humidity * 2));
-  auto temp_value = static_cast<uint8_t>(roundf(temperature * 2));
-  this->write_bytes(0x05, {hum_value, 0x00, temp_value, 0x00});
+  // At page 18 of:
+  // https://cdn.sparkfun.com/datasheets/BreakoutBoards/CCS811_Programming_Guide.pdf
+  // Reference code:
+  // https://github.com/adafruit/Adafruit_CCS811/blob/0990f5c620354d8bc087c4706bec091d8e6e5dfd/Adafruit_CCS811.cpp#L135-L142
+  uint16_t hum_conv = static_cast<uint16_t>(lroundf(humidity * 512.0f + 0.5f));
+  uint16_t temp_conv = static_cast<uint16_t>(lroundf(temperature * 512.0f + 0.5f));
+  this->write_bytes(0x05, {(uint8_t)((hum_conv >> 8) & 0xff), (uint8_t)((hum_conv & 0xff)),
+                           (uint8_t)((temp_conv >> 8) & 0xff), (uint8_t)((temp_conv & 0xff))});
 }
 void CCS811Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CCS811");

esphome/components/ccs811/sensor.py

@@ -1,46 +1,69 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import i2c, sensor
-from esphome.const import CONF_ID, ICON_RADIATOR, UNIT_PARTS_PER_MILLION, \
-    UNIT_PARTS_PER_BILLION, CONF_TEMPERATURE, CONF_HUMIDITY, ICON_MOLECULE_CO2
+from esphome.const import (
+    CONF_ID,
+    ICON_RADIATOR,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PARTS_PER_MILLION,
+    UNIT_PARTS_PER_BILLION,
+    CONF_BASELINE,
+    CONF_ECO2,
+    CONF_TEMPERATURE,
+    CONF_TVOC,
+    CONF_HUMIDITY,
+    ICON_MOLECULE_CO2,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
 
-ccs811_ns = cg.esphome_ns.namespace('ccs811')
-CCS811Component = ccs811_ns.class_('CCS811Component', cg.PollingComponent, i2c.I2CDevice)
+ccs811_ns = cg.esphome_ns.namespace("ccs811")
+CCS811Component = ccs811_ns.class_(
+    "CCS811Component", cg.PollingComponent, i2c.I2CDevice
+)
 
-CONF_ECO2 = 'eco2'
-CONF_TVOC = 'tvoc'
-CONF_BASELINE = 'baseline'
-
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(CCS811Component),
-    cv.Required(CONF_ECO2): sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_MOLECULE_CO2,
-                                                 0),
-    cv.Required(CONF_TVOC): sensor.sensor_schema(UNIT_PARTS_PER_BILLION, ICON_RADIATOR, 0),
-
-    cv.Optional(CONF_BASELINE): cv.hex_uint16_t,
-    cv.Optional(CONF_TEMPERATURE): cv.use_id(sensor.Sensor),
-    cv.Optional(CONF_HUMIDITY): cv.use_id(sensor.Sensor),
-}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x5A))
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CCS811Component),
+            cv.Required(CONF_ECO2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_MILLION,
+                icon=ICON_MOLECULE_CO2,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Required(CONF_TVOC): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_BILLION,
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_BASELINE): cv.hex_uint16_t,
+            cv.Optional(CONF_TEMPERATURE): cv.use_id(sensor.Sensor),
+            cv.Optional(CONF_HUMIDITY): cv.use_id(sensor.Sensor),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x5A))
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield i2c.register_i2c_device(var, config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
 
-    sens = yield sensor.new_sensor(config[CONF_ECO2])
+    sens = await sensor.new_sensor(config[CONF_ECO2])
     cg.add(var.set_co2(sens))
-    sens = yield sensor.new_sensor(config[CONF_TVOC])
+    sens = await sensor.new_sensor(config[CONF_TVOC])
     cg.add(var.set_tvoc(sens))
 
     if CONF_BASELINE in config:
         cg.add(var.set_baseline(config[CONF_BASELINE]))
 
     if CONF_TEMPERATURE in config:
-        sens = yield cg.get_variable(config[CONF_TEMPERATURE])
+        sens = await cg.get_variable(config[CONF_TEMPERATURE])
         cg.add(var.set_temperature(sens))
     if CONF_HUMIDITY in config:
-        sens = yield cg.get_variable(config[CONF_HUMIDITY])
+        sens = await cg.get_variable(config[CONF_HUMIDITY])
         cg.add(var.set_humidity(sens))

esphome/components/climate/__init__.py

@@ -2,75 +2,110 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 from esphome.components import mqtt
-from esphome.const import CONF_AWAY, CONF_ID, CONF_INTERNAL, CONF_MAX_TEMPERATURE, \
-    CONF_MIN_TEMPERATURE, CONF_MODE, CONF_TARGET_TEMPERATURE, \
-    CONF_TARGET_TEMPERATURE_HIGH, CONF_TARGET_TEMPERATURE_LOW, CONF_TEMPERATURE_STEP, CONF_VISUAL, \
-    CONF_MQTT_ID, CONF_NAME, CONF_FAN_MODE, CONF_SWING_MODE
-from esphome.core import CORE, coroutine, coroutine_with_priority
+from esphome.const import (
+    CONF_AWAY,
+    CONF_CUSTOM_FAN_MODE,
+    CONF_CUSTOM_PRESET,
+    CONF_DISABLED_BY_DEFAULT,
+    CONF_ID,
+    CONF_INTERNAL,
+    CONF_MAX_TEMPERATURE,
+    CONF_MIN_TEMPERATURE,
+    CONF_MODE,
+    CONF_PRESET,
+    CONF_TARGET_TEMPERATURE,
+    CONF_TARGET_TEMPERATURE_HIGH,
+    CONF_TARGET_TEMPERATURE_LOW,
+    CONF_TEMPERATURE_STEP,
+    CONF_VISUAL,
+    CONF_MQTT_ID,
+    CONF_NAME,
+    CONF_FAN_MODE,
+    CONF_SWING_MODE,
+)
+from esphome.core import CORE, coroutine_with_priority
 
 IS_PLATFORM_COMPONENT = True
 
-CODEOWNERS = ['@esphome/core']
-climate_ns = cg.esphome_ns.namespace('climate')
+CODEOWNERS = ["@esphome/core"]
+climate_ns = cg.esphome_ns.namespace("climate")
 
-Climate = climate_ns.class_('Climate', cg.Nameable)
-ClimateCall = climate_ns.class_('ClimateCall')
-ClimateTraits = climate_ns.class_('ClimateTraits')
+Climate = climate_ns.class_("Climate", cg.Nameable)
+ClimateCall = climate_ns.class_("ClimateCall")
+ClimateTraits = climate_ns.class_("ClimateTraits")
 
-ClimateMode = climate_ns.enum('ClimateMode')
+ClimateMode = climate_ns.enum("ClimateMode")
 CLIMATE_MODES = {
-    'OFF': ClimateMode.CLIMATE_MODE_OFF,
-    'AUTO': ClimateMode.CLIMATE_MODE_AUTO,
-    'COOL': ClimateMode.CLIMATE_MODE_COOL,
-    'HEAT': ClimateMode.CLIMATE_MODE_HEAT,
-    'DRY': ClimateMode.CLIMATE_MODE_DRY,
-    'FAN_ONLY': ClimateMode.CLIMATE_MODE_FAN_ONLY,
+    "OFF": ClimateMode.CLIMATE_MODE_OFF,
+    "HEAT_COOL": ClimateMode.CLIMATE_MODE_HEAT_COOL,
+    "COOL": ClimateMode.CLIMATE_MODE_COOL,
+    "HEAT": ClimateMode.CLIMATE_MODE_HEAT,
+    "DRY": ClimateMode.CLIMATE_MODE_DRY,
+    "FAN_ONLY": ClimateMode.CLIMATE_MODE_FAN_ONLY,
+    "AUTO": ClimateMode.CLIMATE_MODE_AUTO,
 }
 validate_climate_mode = cv.enum(CLIMATE_MODES, upper=True)
 
-ClimateFanMode = climate_ns.enum('ClimateFanMode')
+ClimateFanMode = climate_ns.enum("ClimateFanMode")
 CLIMATE_FAN_MODES = {
-    'ON': ClimateFanMode.CLIMATE_FAN_ON,
-    'OFF': ClimateFanMode.CLIMATE_FAN_OFF,
-    'AUTO': ClimateFanMode.CLIMATE_FAN_AUTO,
-    'LOW': ClimateFanMode.CLIMATE_FAN_LOW,
-    'MEDIUM': ClimateFanMode.CLIMATE_FAN_MEDIUM,
-    'HIGH': ClimateFanMode.CLIMATE_FAN_HIGH,
-    'MIDDLE': ClimateFanMode.CLIMATE_FAN_MIDDLE,
-    'FOCUS': ClimateFanMode.CLIMATE_FAN_FOCUS,
-    'DIFFUSE': ClimateFanMode.CLIMATE_FAN_DIFFUSE,
+    "ON": ClimateFanMode.CLIMATE_FAN_ON,
+    "OFF": ClimateFanMode.CLIMATE_FAN_OFF,
+    "AUTO": ClimateFanMode.CLIMATE_FAN_AUTO,
+    "LOW": ClimateFanMode.CLIMATE_FAN_LOW,
+    "MEDIUM": ClimateFanMode.CLIMATE_FAN_MEDIUM,
+    "HIGH": ClimateFanMode.CLIMATE_FAN_HIGH,
+    "MIDDLE": ClimateFanMode.CLIMATE_FAN_MIDDLE,
+    "FOCUS": ClimateFanMode.CLIMATE_FAN_FOCUS,
+    "DIFFUSE": ClimateFanMode.CLIMATE_FAN_DIFFUSE,
 }
 
 validate_climate_fan_mode = cv.enum(CLIMATE_FAN_MODES, upper=True)
 
-ClimateSwingMode = climate_ns.enum('ClimateSwingMode')
+ClimatePreset = climate_ns.enum("ClimatePreset")
+CLIMATE_PRESETS = {
+    "ECO": ClimatePreset.CLIMATE_PRESET_ECO,
+    "AWAY": ClimatePreset.CLIMATE_PRESET_AWAY,
+    "BOOST": ClimatePreset.CLIMATE_PRESET_BOOST,
+    "COMFORT": ClimatePreset.CLIMATE_PRESET_COMFORT,
+    "HOME": ClimatePreset.CLIMATE_PRESET_HOME,
+    "SLEEP": ClimatePreset.CLIMATE_PRESET_SLEEP,
+    "ACTIVITY": ClimatePreset.CLIMATE_PRESET_ACTIVITY,
+}
+
+validate_climate_preset = cv.enum(CLIMATE_PRESETS, upper=True)
+
+ClimateSwingMode = climate_ns.enum("ClimateSwingMode")
 CLIMATE_SWING_MODES = {
-    'OFF': ClimateSwingMode.CLIMATE_SWING_OFF,
-    'BOTH': ClimateSwingMode.CLIMATE_SWING_BOTH,
-    'VERTICAL': ClimateSwingMode.CLIMATE_SWING_VERTICAL,
-    'HORIZONTAL': ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
+    "OFF": ClimateSwingMode.CLIMATE_SWING_OFF,
+    "BOTH": ClimateSwingMode.CLIMATE_SWING_BOTH,
+    "VERTICAL": ClimateSwingMode.CLIMATE_SWING_VERTICAL,
+    "HORIZONTAL": ClimateSwingMode.CLIMATE_SWING_HORIZONTAL,
 }
 
 validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True)
 
 # Actions
-ControlAction = climate_ns.class_('ControlAction', automation.Action)
+ControlAction = climate_ns.class_("ControlAction", automation.Action)
 
-CLIMATE_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(Climate),
-    cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTClimateComponent),
-    cv.Optional(CONF_VISUAL, default={}): cv.Schema({
-        cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature,
-        cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature,
-        cv.Optional(CONF_TEMPERATURE_STEP): cv.temperature,
-    }),
-    # TODO: MQTT topic options
-})
+CLIMATE_SCHEMA = cv.NAMEABLE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend(
+    {
+        cv.GenerateID(): cv.declare_id(Climate),
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTClimateComponent),
+        cv.Optional(CONF_VISUAL, default={}): cv.Schema(
+            {
+                cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature,
+                cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature,
+                cv.Optional(CONF_TEMPERATURE_STEP): cv.temperature,
+            }
+        ),
+        # TODO: MQTT topic options
+    }
+)
 
 
-@coroutine
-def setup_climate_core_(var, config):
+async def setup_climate_core_(var, config):
     cg.add(var.set_name(config[CONF_NAME]))
+    cg.add(var.set_disabled_by_default(config[CONF_DISABLED_BY_DEFAULT]))
     if CONF_INTERNAL in config:
         cg.add(var.set_internal(config[CONF_INTERNAL]))
     visual = config[CONF_VISUAL]
@@ -83,58 +118,81 @@ def setup_climate_core_(var, config):
 
     if CONF_MQTT_ID in config:
         mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
-        yield mqtt.register_mqtt_component(mqtt_, config)
+        await mqtt.register_mqtt_component(mqtt_, config)
 
 
-@coroutine
-def register_climate(var, config):
+async def register_climate(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_climate(var))
-    yield setup_climate_core_(var, config)
+    await setup_climate_core_(var, config)
 
 
-CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema({
-    cv.Required(CONF_ID): cv.use_id(Climate),
-    cv.Optional(CONF_MODE): cv.templatable(validate_climate_mode),
-    cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
-    cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
-    cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.templatable(cv.temperature),
-    cv.Optional(CONF_AWAY): cv.templatable(cv.boolean),
-    cv.Optional(CONF_FAN_MODE): cv.templatable(validate_climate_fan_mode),
-    cv.Optional(CONF_SWING_MODE): cv.templatable(validate_climate_swing_mode),
-})
+CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(Climate),
+        cv.Optional(CONF_MODE): cv.templatable(validate_climate_mode),
+        cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
+        cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
+        cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.templatable(cv.temperature),
+        cv.Optional(CONF_AWAY): cv.templatable(cv.boolean),
+        cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
+            validate_climate_fan_mode
+        ),
+        cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.string_strict,
+        cv.Exclusive(CONF_PRESET, "preset"): cv.templatable(validate_climate_preset),
+        cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.string_strict,
+        cv.Optional(CONF_SWING_MODE): cv.templatable(validate_climate_swing_mode),
+    }
+)
 
 
-@automation.register_action('climate.control', ControlAction, CLIMATE_CONTROL_ACTION_SCHEMA)
-def climate_control_to_code(config, action_id, template_arg, args):
-    paren = yield cg.get_variable(config[CONF_ID])
+@automation.register_action(
+    "climate.control", ControlAction, CLIMATE_CONTROL_ACTION_SCHEMA
+)
+async def climate_control_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
     if CONF_MODE in config:
-        template_ = yield cg.templatable(config[CONF_MODE], args, ClimateMode)
+        template_ = await cg.templatable(config[CONF_MODE], args, ClimateMode)
         cg.add(var.set_mode(template_))
     if CONF_TARGET_TEMPERATURE in config:
-        template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE], args, float)
+        template_ = await cg.templatable(config[CONF_TARGET_TEMPERATURE], args, float)
         cg.add(var.set_target_temperature(template_))
     if CONF_TARGET_TEMPERATURE_LOW in config:
-        template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE_LOW], args, float)
+        template_ = await cg.templatable(
+            config[CONF_TARGET_TEMPERATURE_LOW], args, float
+        )
         cg.add(var.set_target_temperature_low(template_))
     if CONF_TARGET_TEMPERATURE_HIGH in config:
-        template_ = yield cg.templatable(config[CONF_TARGET_TEMPERATURE_HIGH], args, float)
+        template_ = await cg.templatable(
+            config[CONF_TARGET_TEMPERATURE_HIGH], args, float
+        )
         cg.add(var.set_target_temperature_high(template_))
     if CONF_AWAY in config:
-        template_ = yield cg.templatable(config[CONF_AWAY], args, bool)
+        template_ = await cg.templatable(config[CONF_AWAY], args, bool)
         cg.add(var.set_away(template_))
     if CONF_FAN_MODE in config:
-        template_ = yield cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
+        template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))
+    if CONF_CUSTOM_FAN_MODE in config:
+        template_ = await cg.templatable(config[CONF_CUSTOM_FAN_MODE], args, str)
+        cg.add(var.set_custom_fan_mode(template_))
+    if CONF_PRESET in config:
+        template_ = await cg.templatable(config[CONF_PRESET], args, ClimatePreset)
+        cg.add(var.set_preset(template_))
+    if CONF_CUSTOM_PRESET in config:
+        template_ = await cg.templatable(config[CONF_CUSTOM_PRESET], args, str)
+        cg.add(var.set_custom_preset(template_))
     if CONF_SWING_MODE in config:
-        template_ = yield cg.templatable(config[CONF_SWING_MODE], args, ClimateSwingMode)
+        template_ = await cg.templatable(
+            config[CONF_SWING_MODE], args, ClimateSwingMode
+        )
         cg.add(var.set_swing_mode(template_))
-    yield var
+    return var
 
 
 @coroutine_with_priority(100.0)
-def to_code(config):
-    cg.add_define('USE_CLIMATE')
+async def to_code(config):
+    cg.add_define("USE_CLIMATE")
     cg.add_global(climate_ns.using)

esphome/components/climate/automation.h

@@ -16,6 +16,9 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
   TEMPLATABLE_VALUE(float, target_temperature_high)
   TEMPLATABLE_VALUE(bool, away)
   TEMPLATABLE_VALUE(ClimateFanMode, fan_mode)
+  TEMPLATABLE_VALUE(std::string, custom_fan_mode)
+  TEMPLATABLE_VALUE(ClimatePreset, preset)
+  TEMPLATABLE_VALUE(std::string, custom_preset)
   TEMPLATABLE_VALUE(ClimateSwingMode, swing_mode)
 
   void play(Ts... x) override {
@@ -24,8 +27,13 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
     call.set_target_temperature(this->target_temperature_.optional_value(x...));
     call.set_target_temperature_low(this->target_temperature_low_.optional_value(x...));
     call.set_target_temperature_high(this->target_temperature_high_.optional_value(x...));
-    call.set_away(this->away_.optional_value(x...));
+    if (away_.has_value()) {
+      call.set_preset(away_.value(x...) ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME);
+    }
     call.set_fan_mode(this->fan_mode_.optional_value(x...));
+    call.set_fan_mode(this->custom_fan_mode_.optional_value(x...));
+    call.set_preset(this->preset_.optional_value(x...));
+    call.set_preset(this->custom_preset_.optional_value(x...));
     call.set_swing_mode(this->swing_mode_.optional_value(x...));
     call.perform();
   }

esphome/components/climate/climate.cpp

@@ -1,10 +1,9 @@
 #include "climate.h"
-#include "esphome/core/log.h"
 
 namespace esphome {
 namespace climate {
 
-static const char *TAG = "climate";
+static const char *const TAG = "climate";
 
 void ClimateCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
@@ -13,10 +12,24 @@ void ClimateCall::perform() {
     const char *mode_s = climate_mode_to_string(*this->mode_);
     ESP_LOGD(TAG, "  Mode: %s", mode_s);
   }
+  if (this->custom_fan_mode_.has_value()) {
+    this->fan_mode_.reset();
+    ESP_LOGD(TAG, " Custom Fan: %s", this->custom_fan_mode_.value().c_str());
+  }
   if (this->fan_mode_.has_value()) {
+    this->custom_fan_mode_.reset();
     const char *fan_mode_s = climate_fan_mode_to_string(*this->fan_mode_);
     ESP_LOGD(TAG, "  Fan: %s", fan_mode_s);
   }
+  if (this->custom_preset_.has_value()) {
+    this->preset_.reset();
+    ESP_LOGD(TAG, " Custom Preset: %s", this->custom_preset_.value().c_str());
+  }
+  if (this->preset_.has_value()) {
+    this->custom_preset_.reset();
+    const char *preset_s = climate_preset_to_string(*this->preset_);
+    ESP_LOGD(TAG, "  Preset: %s", preset_s);
+  }
   if (this->swing_mode_.has_value()) {
     const char *swing_mode_s = climate_swing_mode_to_string(*this->swing_mode_);
     ESP_LOGD(TAG, "  Swing: %s", swing_mode_s);
@@ -30,9 +43,6 @@ void ClimateCall::perform() {
   if (this->target_temperature_high_.has_value()) {
     ESP_LOGD(TAG, "  Target Temperature High: %.2f", *this->target_temperature_high_);
   }
-  if (this->away_.has_value()) {
-    ESP_LOGD(TAG, "  Away Mode: %s", ONOFF(*this->away_));
-  }
   this->parent_->control(*this);
 }
 void ClimateCall::validate_() {
@@ -44,13 +54,32 @@ void ClimateCall::validate_() {
       this->mode_.reset();
     }
   }
-  if (this->fan_mode_.has_value()) {
+  if (this->custom_fan_mode_.has_value()) {
+    auto custom_fan_mode = *this->custom_fan_mode_;
+    if (!traits.supports_custom_fan_mode(custom_fan_mode)) {
+      ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!", custom_fan_mode.c_str());
+      this->custom_fan_mode_.reset();
+    }
+  } else if (this->fan_mode_.has_value()) {
     auto fan_mode = *this->fan_mode_;
     if (!traits.supports_fan_mode(fan_mode)) {
       ESP_LOGW(TAG, "  Fan Mode %s is not supported by this device!", climate_fan_mode_to_string(fan_mode));
       this->fan_mode_.reset();
     }
   }
+  if (this->custom_preset_.has_value()) {
+    auto custom_preset = *this->custom_preset_;
+    if (!traits.supports_custom_preset(custom_preset)) {
+      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", custom_preset.c_str());
+      this->custom_preset_.reset();
+    }
+  } else if (this->preset_.has_value()) {
+    auto preset = *this->preset_;
+    if (!traits.supports_preset(preset)) {
+      ESP_LOGW(TAG, "  Preset %s is not supported by this device!", climate_preset_to_string(preset));
+      this->preset_.reset();
+    }
+  }
   if (this->swing_mode_.has_value()) {
     auto swing_mode = *this->swing_mode_;
     if (!traits.supports_swing_mode(swing_mode)) {
@@ -93,12 +122,6 @@ void ClimateCall::validate_() {
       this->target_temperature_high_.reset();
     }
   }
-  if (this->away_.has_value()) {
-    if (!traits.get_supports_away()) {
-      ESP_LOGW(TAG, "  Cannot set away mode for this device!");
-      this->away_.reset();
-    }
-  }
 }
 ClimateCall &ClimateCall::set_mode(ClimateMode mode) {
   this->mode_ = mode;
@@ -117,6 +140,8 @@ ClimateCall &ClimateCall::set_mode(const std::string &mode) {
     this->set_mode(CLIMATE_MODE_FAN_ONLY);
   } else if (str_equals_case_insensitive(mode, "DRY")) {
     this->set_mode(CLIMATE_MODE_DRY);
+  } else if (str_equals_case_insensitive(mode, "HEAT_COOL")) {
+    this->set_mode(CLIMATE_MODE_HEAT_COOL);
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized mode %s", this->parent_->get_name().c_str(), mode.c_str());
   }
@@ -124,6 +149,7 @@ ClimateCall &ClimateCall::set_mode(const std::string &mode) {
 }
 ClimateCall &ClimateCall::set_fan_mode(ClimateFanMode fan_mode) {
   this->fan_mode_ = fan_mode;
+  this->custom_fan_mode_.reset();
   return *this;
 }
 ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
@@ -146,11 +172,57 @@ ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
   } else if (str_equals_case_insensitive(fan_mode, "DIFFUSE")) {
     this->set_fan_mode(CLIMATE_FAN_DIFFUSE);
   } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
+    if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
+      this->custom_fan_mode_ = fan_mode;
+      this->fan_mode_.reset();
+    } else {
+      ESP_LOGW(TAG, "'%s' - Unrecognized fan mode %s", this->parent_->get_name().c_str(), fan_mode.c_str());
+    }
+  }
+  return *this;
+}
+ClimateCall &ClimateCall::set_fan_mode(optional<std::string> fan_mode) {
+  if (fan_mode.has_value()) {
+    this->set_fan_mode(fan_mode.value());
+  }
+  return *this;
+}
+ClimateCall &ClimateCall::set_preset(ClimatePreset preset) {
+  this->preset_ = preset;
+  this->custom_preset_.reset();
+  return *this;
+}
+ClimateCall &ClimateCall::set_preset(const std::string &preset) {
+  if (str_equals_case_insensitive(preset, "ECO")) {
+    this->set_preset(CLIMATE_PRESET_ECO);
+  } else if (str_equals_case_insensitive(preset, "AWAY")) {
+    this->set_preset(CLIMATE_PRESET_AWAY);
+  } else if (str_equals_case_insensitive(preset, "BOOST")) {
+    this->set_preset(CLIMATE_PRESET_BOOST);
+  } else if (str_equals_case_insensitive(preset, "COMFORT")) {
+    this->set_preset(CLIMATE_PRESET_COMFORT);
+  } else if (str_equals_case_insensitive(preset, "HOME")) {
+    this->set_preset(CLIMATE_PRESET_HOME);
+  } else if (str_equals_case_insensitive(preset, "SLEEP")) {
+    this->set_preset(CLIMATE_PRESET_SLEEP);
+  } else if (str_equals_case_insensitive(preset, "ACTIVITY")) {
+    this->set_preset(CLIMATE_PRESET_ACTIVITY);
+  } else {
+    if (this->parent_->get_traits().supports_custom_preset(preset)) {
+      this->custom_preset_ = preset;
+      this->preset_.reset();
+    } else {
+      ESP_LOGW(TAG, "'%s' - Unrecognized preset %s", this->parent_->get_name().c_str(), preset.c_str());
+    }
+  }
+  return *this;
+}
+ClimateCall &ClimateCall::set_preset(optional<std::string> preset) {
+  if (preset.has_value()) {
+    this->set_preset(preset.value());
   }
   return *this;
 }
-
 ClimateCall &ClimateCall::set_swing_mode(ClimateSwingMode swing_mode) {
   this->swing_mode_ = swing_mode;
   return *this;
@@ -186,15 +258,23 @@ const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_;
 const optional<float> &ClimateCall::get_target_temperature() const { return this->target_temperature_; }
 const optional<float> &ClimateCall::get_target_temperature_low() const { return this->target_temperature_low_; }
 const optional<float> &ClimateCall::get_target_temperature_high() const { return this->target_temperature_high_; }
-const optional<bool> &ClimateCall::get_away() const { return this->away_; }
+optional<bool> ClimateCall::get_away() const {
+  if (!this->preset_.has_value())
+    return {};
+  return *this->preset_ == ClimatePreset::CLIMATE_PRESET_AWAY;
+}
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
+const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
+const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
+const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
 const optional<ClimateSwingMode> &ClimateCall::get_swing_mode() const { return this->swing_mode_; }
 ClimateCall &ClimateCall::set_away(bool away) {
-  this->away_ = away;
+  this->preset_ = away ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME;
   return *this;
 }
 ClimateCall &ClimateCall::set_away(optional<bool> away) {
-  this->away_ = away;
+  if (away.has_value())
+    this->preset_ = *away ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME;
   return *this;
 }
 ClimateCall &ClimateCall::set_target_temperature_high(optional<float> target_temperature_high) {
@@ -215,6 +295,12 @@ ClimateCall &ClimateCall::set_mode(optional<ClimateMode> mode) {
 }
 ClimateCall &ClimateCall::set_fan_mode(optional<ClimateFanMode> fan_mode) {
   this->fan_mode_ = fan_mode;
+  this->custom_fan_mode_.reset();
+  return *this;
+}
+ClimateCall &ClimateCall::set_preset(optional<ClimatePreset> preset) {
+  this->preset_ = preset;
+  this->custom_preset_.reset();
   return *this;
 }
 ClimateCall &ClimateCall::set_swing_mode(optional<ClimateSwingMode> swing_mode) {
@@ -226,8 +312,12 @@ void Climate::add_on_state_callback(std::function<void()> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
+// Random 32bit value; If this changes existing restore preferences are invalidated
+static const uint32_t RESTORE_STATE_VERSION = 0x848EA6ADUL;
+
 optional<ClimateDeviceRestoreState> Climate::restore_state_() {
-  this->rtc_ = global_preferences.make_preference<ClimateDeviceRestoreState>(this->get_object_id_hash());
+  this->rtc_ =
+      global_preferences.make_preference<ClimateDeviceRestoreState>(this->get_object_id_hash() ^ RESTORE_STATE_VERSION);
   ClimateDeviceRestoreState recovered{};
   if (!this->rtc_.load(&recovered))
     return {};
@@ -246,11 +336,32 @@ void Climate::save_state_() {
   } else {
     state.target_temperature = this->target_temperature;
   }
-  if (traits.get_supports_away()) {
-    state.away = this->away;
+  if (traits.get_supports_fan_modes() && fan_mode.has_value()) {
+    state.uses_custom_fan_mode = false;
+    state.fan_mode = this->fan_mode.value();
   }
-  if (traits.get_supports_fan_modes()) {
-    state.fan_mode = this->fan_mode;
+  if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
+    state.uses_custom_fan_mode = true;
+    const auto &supported = traits.get_supported_custom_fan_modes();
+    std::vector<std::string> vec{supported.begin(), supported.end()};
+    auto it = std::find(vec.begin(), vec.end(), custom_fan_mode);
+    if (it != vec.end()) {
+      state.custom_fan_mode = std::distance(vec.begin(), it);
+    }
+  }
+  if (traits.get_supports_presets() && preset.has_value()) {
+    state.uses_custom_preset = false;
+    state.preset = this->preset.value();
+  }
+  if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
+    state.uses_custom_preset = true;
+    const auto &supported = traits.get_supported_custom_presets();
+    std::vector<std::string> vec{supported.begin(), supported.end()};
+    auto it = std::find(vec.begin(), vec.end(), custom_preset);
+    // only set custom preset if value exists, otherwise leave it as is
+    if (it != vec.cend()) {
+      state.custom_preset = std::distance(vec.begin(), it);
+    }
   }
   if (traits.get_supports_swing_modes()) {
     state.swing_mode = this->swing_mode;
@@ -266,8 +377,17 @@ void Climate::publish_state() {
   if (traits.get_supports_action()) {
     ESP_LOGD(TAG, "  Action: %s", climate_action_to_string(this->action));
   }
-  if (traits.get_supports_fan_modes()) {
-    ESP_LOGD(TAG, "  Fan Mode: %s", climate_fan_mode_to_string(this->fan_mode));
+  if (traits.get_supports_fan_modes() && this->fan_mode.has_value()) {
+    ESP_LOGD(TAG, "  Fan Mode: %s", climate_fan_mode_to_string(this->fan_mode.value()));
+  }
+  if (!traits.get_supported_custom_fan_modes().empty() && this->custom_fan_mode.has_value()) {
+    ESP_LOGD(TAG, "  Custom Fan Mode: %s", this->custom_fan_mode.value().c_str());
+  }
+  if (traits.get_supports_presets() && this->preset.has_value()) {
+    ESP_LOGD(TAG, "  Preset: %s", climate_preset_to_string(this->preset.value()));
+  }
+  if (!traits.get_supported_custom_presets().empty() && this->custom_preset.has_value()) {
+    ESP_LOGD(TAG, "  Custom Preset: %s", this->custom_preset.value().c_str());
   }
   if (traits.get_supports_swing_modes()) {
     ESP_LOGD(TAG, "  Swing Mode: %s", climate_swing_mode_to_string(this->swing_mode));
@@ -281,9 +401,6 @@ void Climate::publish_state() {
   } else {
     ESP_LOGD(TAG, "  Target Temperature: %.2f°C", this->target_temperature);
   }
-  if (traits.get_supports_away()) {
-    ESP_LOGD(TAG, "  Away: %s", ONOFF(this->away));
-  }
 
   // Send state to frontend
   this->state_callback_.call();
@@ -329,12 +446,12 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   } else {
     call.set_target_temperature(this->target_temperature);
   }
-  if (traits.get_supports_away()) {
-    call.set_away(this->away);
-  }
-  if (traits.get_supports_fan_modes()) {
+  if (traits.get_supports_fan_modes() || !traits.get_supported_custom_fan_modes().empty()) {
     call.set_fan_mode(this->fan_mode);
   }
+  if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
+    call.set_preset(this->preset);
+  }
   if (traits.get_supports_swing_modes()) {
     call.set_swing_mode(this->swing_mode);
   }
@@ -349,12 +466,28 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   } else {
     climate->target_temperature = this->target_temperature;
   }
-  if (traits.get_supports_away()) {
-    climate->away = this->away;
-  }
-  if (traits.get_supports_fan_modes()) {
+  if (traits.get_supports_fan_modes() && !this->uses_custom_fan_mode) {
     climate->fan_mode = this->fan_mode;
   }
+  if (!traits.get_supported_custom_fan_modes().empty() && this->uses_custom_fan_mode) {
+    // std::set has consistent order (lexicographic for strings), so this is ok
+    const auto &modes = traits.get_supported_custom_fan_modes();
+    std::vector<std::string> modes_vec{modes.begin(), modes.end()};
+    if (custom_fan_mode < modes_vec.size()) {
+      climate->custom_fan_mode = modes_vec[this->custom_fan_mode];
+    }
+  }
+  if (traits.get_supports_presets() && !this->uses_custom_preset) {
+    climate->preset = this->preset;
+  }
+  if (!traits.get_supported_custom_presets().empty() && uses_custom_preset) {
+    // std::set has consistent order (lexicographic for strings), so this is ok
+    const auto &presets = traits.get_supported_custom_presets();
+    std::vector<std::string> presets_vec{presets.begin(), presets.end()};
+    if (custom_preset < presets_vec.size()) {
+      climate->custom_preset = presets_vec[this->custom_preset];
+    }
+  }
   if (traits.get_supports_swing_modes()) {
     climate->swing_mode = this->swing_mode;
   }

esphome/components/climate/climate.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 
@@ -10,8 +11,8 @@ namespace esphome {
 namespace climate {
 
 #define LOG_CLIMATE(prefix, type, obj) \
-  if (obj != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, obj->get_name().c_str()); \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
   }
 
 class Climate;
@@ -62,7 +63,9 @@ class ClimateCall {
    * For climate devices with two point target temperature control
    */
   ClimateCall &set_target_temperature_high(optional<float> target_temperature_high);
+  ESPDEPRECATED("set_away() is deprecated, please use .set_preset(CLIMATE_PRESET_AWAY) instead", "v1.20")
   ClimateCall &set_away(bool away);
+  ESPDEPRECATED("set_away() is deprecated, please use .set_preset(CLIMATE_PRESET_AWAY) instead", "v1.20")
   ClimateCall &set_away(optional<bool> away);
   /// Set the fan mode of the climate device.
   ClimateCall &set_fan_mode(ClimateFanMode fan_mode);
@@ -70,12 +73,22 @@ class ClimateCall {
   ClimateCall &set_fan_mode(optional<ClimateFanMode> fan_mode);
   /// Set the fan mode of the climate device based on a string.
   ClimateCall &set_fan_mode(const std::string &fan_mode);
+  /// Set the fan mode of the climate device based on a string.
+  ClimateCall &set_fan_mode(optional<std::string> fan_mode);
   /// Set the swing mode of the climate device.
   ClimateCall &set_swing_mode(ClimateSwingMode swing_mode);
   /// Set the swing mode of the climate device.
   ClimateCall &set_swing_mode(optional<ClimateSwingMode> swing_mode);
   /// Set the swing mode of the climate device based on a string.
   ClimateCall &set_swing_mode(const std::string &swing_mode);
+  /// Set the preset of the climate device.
+  ClimateCall &set_preset(ClimatePreset preset);
+  /// Set the preset of the climate device.
+  ClimateCall &set_preset(optional<ClimatePreset> preset);
+  /// Set the preset of the climate device based on a string.
+  ClimateCall &set_preset(const std::string &preset);
+  /// Set the preset of the climate device based on a string.
+  ClimateCall &set_preset(optional<std::string> preset);
 
   void perform();
 
@@ -83,9 +96,13 @@ class ClimateCall {
   const optional<float> &get_target_temperature() const;
   const optional<float> &get_target_temperature_low() const;
   const optional<float> &get_target_temperature_high() const;
-  const optional<bool> &get_away() const;
+  ESPDEPRECATED("get_away() is deprecated, please use .get_preset() instead", "v1.20")
+  optional<bool> get_away() const;
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
+  const optional<std::string> &get_custom_fan_mode() const;
+  const optional<ClimatePreset> &get_preset() const;
+  const optional<std::string> &get_custom_preset() const;
 
  protected:
   void validate_();
@@ -95,16 +112,27 @@ class ClimateCall {
   optional<float> target_temperature_;
   optional<float> target_temperature_low_;
   optional<float> target_temperature_high_;
-  optional<bool> away_;
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
+  optional<std::string> custom_fan_mode_;
+  optional<ClimatePreset> preset_;
+  optional<std::string> custom_preset_;
 };
 
 /// Struct used to save the state of the climate device in restore memory.
+/// Make sure to update RESTORE_STATE_VERSION when changing the struct entries.
 struct ClimateDeviceRestoreState {
   ClimateMode mode;
-  bool away;
-  ClimateFanMode fan_mode;
+  bool uses_custom_fan_mode{false};
+  union {
+    ClimateFanMode fan_mode;
+    uint8_t custom_fan_mode;
+  };
+  bool uses_custom_preset{false};
+  union {
+    ClimatePreset preset;
+    uint8_t custom_preset;
+  };
   ClimateSwingMode swing_mode;
   union {
     float target_temperature;
@@ -133,7 +161,7 @@ struct ClimateDeviceRestoreState {
  *
  * The entire state of the climate device is encoded in public properties of the base class (current_temperature,
  * mode etc). These are read-only for the user and rw for integrations. The reason these are public
- * is for simple access to them from lambdas `if (id(my_climate).mode == climate::CLIMATE_MODE_AUTO) ...`
+ * is for simple access to them from lambdas `if (id(my_climate).mode == climate::CLIMATE_MODE_HEAT_COOL) ...`
  */
 class Climate : public Nameable {
  public:
@@ -165,14 +193,24 @@ class Climate : public Nameable {
    * Away allows climate devices to have two different target temperature configs:
    * one for normal mode and one for away mode.
    */
+  ESPDEPRECATED("away is deprecated, use preset instead", "v1.20")
   bool away{false};
 
   /// The active fan mode of the climate device.
-  ClimateFanMode fan_mode;
+  optional<ClimateFanMode> fan_mode;
 
   /// The active swing mode of the climate device.
   ClimateSwingMode swing_mode;
 
+  /// The active custom fan mode of the climate device.
+  optional<std::string> custom_fan_mode;
+
+  /// The active preset of the climate device.
+  optional<ClimatePreset> preset;
+
+  /// The active custom preset mode of the climate device.
+  optional<std::string> custom_preset;
+
   /** Add a callback for the climate device state, each time the state of the climate device is updated
    * (using publish_state), this callback will be called.
    *

esphome/components/climate/climate_mode.cpp

@@ -17,6 +17,8 @@ const char *climate_mode_to_string(ClimateMode mode) {
       return "FAN_ONLY";
     case CLIMATE_MODE_DRY:
       return "DRY";
+    case CLIMATE_MODE_HEAT_COOL:
+      return "HEAT_COOL";
     default:
       return "UNKNOWN";
   }
@@ -80,5 +82,28 @@ const char *climate_swing_mode_to_string(ClimateSwingMode swing_mode) {
   }
 }
 
+const char *climate_preset_to_string(ClimatePreset preset) {
+  switch (preset) {
+    case climate::CLIMATE_PRESET_NONE:
+      return "NONE";
+    case climate::CLIMATE_PRESET_HOME:
+      return "HOME";
+    case climate::CLIMATE_PRESET_ECO:
+      return "ECO";
+    case climate::CLIMATE_PRESET_AWAY:
+      return "AWAY";
+    case climate::CLIMATE_PRESET_BOOST:
+      return "BOOST";
+    case climate::CLIMATE_PRESET_COMFORT:
+      return "COMFORT";
+    case climate::CLIMATE_PRESET_SLEEP:
+      return "SLEEP";
+    case climate::CLIMATE_PRESET_ACTIVITY:
+      return "ACTIVITY";
+    default:
+      return "UNKNOWN";
+  }
+}
+
 }  // namespace climate
 }  // namespace esphome

esphome/components/climate/climate_mode.h

@@ -7,37 +7,41 @@ namespace climate {
 
 /// Enum for all modes a climate device can be in.
 enum ClimateMode : uint8_t {
-  /// The climate device is off (not in auto, heat or cool mode)
+  /// The climate device is off
   CLIMATE_MODE_OFF = 0,
-  /// The climate device is set to automatically change the heating/cooling cycle
-  CLIMATE_MODE_AUTO = 1,
-  /// The climate device is manually set to cool mode (not in auto mode!)
+  /// The climate device is set to heat/cool to reach the target temperature.
+  CLIMATE_MODE_HEAT_COOL = 1,
+  /// The climate device is set to cool to reach the target temperature
   CLIMATE_MODE_COOL = 2,
-  /// The climate device is manually set to heat mode (not in auto mode!)
+  /// The climate device is set to heat to reach the target temperature
   CLIMATE_MODE_HEAT = 3,
-  /// The climate device is manually set to fan only mode
+  /// The climate device only has the fan enabled, no heating or cooling is taking place
   CLIMATE_MODE_FAN_ONLY = 4,
-  /// The climate device is manually set to dry mode
+  /// The climate device is set to dry/humidity mode
   CLIMATE_MODE_DRY = 5,
+  /** The climate device is adjusting the temperatre dynamically.
+   * For example, the target temperature can be adjusted based on a schedule, or learned behavior.
+   * The target temperature can't be adjusted when in this mode.
+   */
+  CLIMATE_MODE_AUTO = 6
 };
 
 /// Enum for the current action of the climate device. Values match those of ClimateMode.
 enum ClimateAction : uint8_t {
   /// The climate device is off (inactive or no power)
   CLIMATE_ACTION_OFF = 0,
-  /// The climate device is actively cooling (usually in cool or auto mode)
+  /// The climate device is actively cooling
   CLIMATE_ACTION_COOLING = 2,
-  /// The climate device is actively heating (usually in heat or auto mode)
+  /// The climate device is actively heating
   CLIMATE_ACTION_HEATING = 3,
   /// The climate device is idle (monitoring climate but no action needed)
   CLIMATE_ACTION_IDLE = 4,
-  /// The climate device is drying (either mode DRY or AUTO)
+  /// The climate device is drying
   CLIMATE_ACTION_DRYING = 5,
-  /// The climate device is in fan only mode (either mode FAN_ONLY or AUTO)
+  /// The climate device is in fan only mode
   CLIMATE_ACTION_FAN = 6,
 };
 
-/// Enum for all modes a climate fan can be in
 enum ClimateFanMode : uint8_t {
   /// The fan mode is set to On
   CLIMATE_FAN_ON = 0,
@@ -61,7 +65,7 @@ enum ClimateFanMode : uint8_t {
 
 /// Enum for all modes a climate swing can be in
 enum ClimateSwingMode : uint8_t {
-  /// The sing mode is set to Off
+  /// The swing mode is set to Off
   CLIMATE_SWING_OFF = 0,
   /// The fan mode is set to Both
   CLIMATE_SWING_BOTH = 1,
@@ -71,6 +75,26 @@ enum ClimateSwingMode : uint8_t {
   CLIMATE_SWING_HORIZONTAL = 3,
 };
 
+/// Enum for all modes a climate swing can be in
+enum ClimatePreset : uint8_t {
+  /// No preset is active
+  CLIMATE_PRESET_NONE = 0,
+  /// Device is in home preset
+  CLIMATE_PRESET_HOME = 1,
+  /// Device is in away preset
+  CLIMATE_PRESET_AWAY = 2,
+  /// Device is in boost preset
+  CLIMATE_PRESET_BOOST = 3,
+  /// Device is in comfort preset
+  CLIMATE_PRESET_COMFORT = 4,
+  /// Device is running an energy-saving preset
+  CLIMATE_PRESET_ECO = 5,
+  /// Device is prepared for sleep
+  CLIMATE_PRESET_SLEEP = 6,
+  /// Device is reacting to activity (e.g., movement sensors)
+  CLIMATE_PRESET_ACTIVITY = 7,
+};
+
 /// Convert the given ClimateMode to a human-readable string.
 const char *climate_mode_to_string(ClimateMode mode);
 
@@ -83,5 +107,8 @@ const char *climate_fan_mode_to_string(ClimateFanMode mode);
 /// Convert the given ClimateSwingMode to a human-readable string.
 const char *climate_swing_mode_to_string(ClimateSwingMode mode);
 
+/// Convert the given ClimateSwingMode to a human-readable string.
+const char *climate_preset_to_string(ClimatePreset preset);
+
 }  // namespace climate
 }  // namespace esphome

esphome/components/climate/climate_traits.cpp

@@ -4,50 +4,6 @@
 namespace esphome {
 namespace climate {
 
-bool ClimateTraits::supports_mode(ClimateMode mode) const {
-  switch (mode) {
-    case CLIMATE_MODE_OFF:
-      return true;
-    case CLIMATE_MODE_AUTO:
-      return this->supports_auto_mode_;
-    case CLIMATE_MODE_COOL:
-      return this->supports_cool_mode_;
-    case CLIMATE_MODE_HEAT:
-      return this->supports_heat_mode_;
-    case CLIMATE_MODE_FAN_ONLY:
-      return this->supports_fan_only_mode_;
-    case CLIMATE_MODE_DRY:
-      return this->supports_dry_mode_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_current_temperature() const { return supports_current_temperature_; }
-void ClimateTraits::set_supports_current_temperature(bool supports_current_temperature) {
-  supports_current_temperature_ = supports_current_temperature;
-}
-bool ClimateTraits::get_supports_two_point_target_temperature() const { return supports_two_point_target_temperature_; }
-void ClimateTraits::set_supports_two_point_target_temperature(bool supports_two_point_target_temperature) {
-  supports_two_point_target_temperature_ = supports_two_point_target_temperature;
-}
-void ClimateTraits::set_supports_auto_mode(bool supports_auto_mode) { supports_auto_mode_ = supports_auto_mode; }
-void ClimateTraits::set_supports_cool_mode(bool supports_cool_mode) { supports_cool_mode_ = supports_cool_mode; }
-void ClimateTraits::set_supports_heat_mode(bool supports_heat_mode) { supports_heat_mode_ = supports_heat_mode; }
-void ClimateTraits::set_supports_fan_only_mode(bool supports_fan_only_mode) {
-  supports_fan_only_mode_ = supports_fan_only_mode;
-}
-void ClimateTraits::set_supports_dry_mode(bool supports_dry_mode) { supports_dry_mode_ = supports_dry_mode; }
-void ClimateTraits::set_supports_away(bool supports_away) { supports_away_ = supports_away; }
-void ClimateTraits::set_supports_action(bool supports_action) { supports_action_ = supports_action; }
-float ClimateTraits::get_visual_min_temperature() const { return visual_min_temperature_; }
-void ClimateTraits::set_visual_min_temperature(float visual_min_temperature) {
-  visual_min_temperature_ = visual_min_temperature;
-}
-float ClimateTraits::get_visual_max_temperature() const { return visual_max_temperature_; }
-void ClimateTraits::set_visual_max_temperature(float visual_max_temperature) {
-  visual_max_temperature_ = visual_max_temperature;
-}
-float ClimateTraits::get_visual_temperature_step() const { return visual_temperature_step_; }
 int8_t ClimateTraits::get_temperature_accuracy_decimals() const {
   // use printf %g to find number of digits based on temperature step
   char buf[32];
@@ -59,95 +15,6 @@ int8_t ClimateTraits::get_temperature_accuracy_decimals() const {
 
   return str.length() - dot_pos - 1;
 }
-void ClimateTraits::set_visual_temperature_step(float temperature_step) { visual_temperature_step_ = temperature_step; }
-bool ClimateTraits::get_supports_away() const { return supports_away_; }
-bool ClimateTraits::get_supports_action() const { return supports_action_; }
 
-void ClimateTraits::set_supports_fan_mode_on(bool supports_fan_mode_on) {
-  this->supports_fan_mode_on_ = supports_fan_mode_on;
-}
-void ClimateTraits::set_supports_fan_mode_off(bool supports_fan_mode_off) {
-  this->supports_fan_mode_off_ = supports_fan_mode_off;
-}
-void ClimateTraits::set_supports_fan_mode_auto(bool supports_fan_mode_auto) {
-  this->supports_fan_mode_auto_ = supports_fan_mode_auto;
-}
-void ClimateTraits::set_supports_fan_mode_low(bool supports_fan_mode_low) {
-  this->supports_fan_mode_low_ = supports_fan_mode_low;
-}
-void ClimateTraits::set_supports_fan_mode_medium(bool supports_fan_mode_medium) {
-  this->supports_fan_mode_medium_ = supports_fan_mode_medium;
-}
-void ClimateTraits::set_supports_fan_mode_high(bool supports_fan_mode_high) {
-  this->supports_fan_mode_high_ = supports_fan_mode_high;
-}
-void ClimateTraits::set_supports_fan_mode_middle(bool supports_fan_mode_middle) {
-  this->supports_fan_mode_middle_ = supports_fan_mode_middle;
-}
-void ClimateTraits::set_supports_fan_mode_focus(bool supports_fan_mode_focus) {
-  this->supports_fan_mode_focus_ = supports_fan_mode_focus;
-}
-void ClimateTraits::set_supports_fan_mode_diffuse(bool supports_fan_mode_diffuse) {
-  this->supports_fan_mode_diffuse_ = supports_fan_mode_diffuse;
-}
-bool ClimateTraits::supports_fan_mode(ClimateFanMode fan_mode) const {
-  switch (fan_mode) {
-    case climate::CLIMATE_FAN_ON:
-      return this->supports_fan_mode_on_;
-    case climate::CLIMATE_FAN_OFF:
-      return this->supports_fan_mode_off_;
-    case climate::CLIMATE_FAN_AUTO:
-      return this->supports_fan_mode_auto_;
-    case climate::CLIMATE_FAN_LOW:
-      return this->supports_fan_mode_low_;
-    case climate::CLIMATE_FAN_MEDIUM:
-      return this->supports_fan_mode_medium_;
-    case climate::CLIMATE_FAN_HIGH:
-      return this->supports_fan_mode_high_;
-    case climate::CLIMATE_FAN_MIDDLE:
-      return this->supports_fan_mode_middle_;
-    case climate::CLIMATE_FAN_FOCUS:
-      return this->supports_fan_mode_focus_;
-    case climate::CLIMATE_FAN_DIFFUSE:
-      return this->supports_fan_mode_diffuse_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_fan_modes() const {
-  return this->supports_fan_mode_on_ || this->supports_fan_mode_off_ || this->supports_fan_mode_auto_ ||
-         this->supports_fan_mode_low_ || this->supports_fan_mode_medium_ || this->supports_fan_mode_high_ ||
-         this->supports_fan_mode_middle_ || this->supports_fan_mode_focus_ || this->supports_fan_mode_diffuse_;
-}
-void ClimateTraits::set_supports_swing_mode_off(bool supports_swing_mode_off) {
-  this->supports_swing_mode_off_ = supports_swing_mode_off;
-}
-void ClimateTraits::set_supports_swing_mode_both(bool supports_swing_mode_both) {
-  this->supports_swing_mode_both_ = supports_swing_mode_both;
-}
-void ClimateTraits::set_supports_swing_mode_vertical(bool supports_swing_mode_vertical) {
-  this->supports_swing_mode_vertical_ = supports_swing_mode_vertical;
-}
-void ClimateTraits::set_supports_swing_mode_horizontal(bool supports_swing_mode_horizontal) {
-  this->supports_swing_mode_horizontal_ = supports_swing_mode_horizontal;
-}
-bool ClimateTraits::supports_swing_mode(ClimateSwingMode swing_mode) const {
-  switch (swing_mode) {
-    case climate::CLIMATE_SWING_OFF:
-      return this->supports_swing_mode_off_;
-    case climate::CLIMATE_SWING_BOTH:
-      return this->supports_swing_mode_both_;
-    case climate::CLIMATE_SWING_VERTICAL:
-      return this->supports_swing_mode_vertical_;
-    case climate::CLIMATE_SWING_HORIZONTAL:
-      return this->supports_swing_mode_horizontal_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_swing_modes() const {
-  return this->supports_swing_mode_off_ || this->supports_swing_mode_both_ || supports_swing_mode_vertical_ ||
-         supports_swing_mode_horizontal_;
-}
 }  // namespace climate
 }  // namespace esphome

esphome/components/climate/climate_traits.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include "esphome/core/helpers.h"
 #include "climate_mode.h"
+#include <set>
 
 namespace esphome {
 namespace climate {
@@ -23,8 +25,6 @@ namespace climate {
  *    - heat mode (increases current temperature)
  *    - dry mode (removes humidity from air)
  *    - fan mode (only turns on fan)
- *  - supports away - away mode means that the climate device supports two different
- *      target temperature settings: one target temp setting for "away" mode and one for non-away mode.
  *  - supports action - if the climate device supports reporting the active
  *    current action of the device with the action property.
  *  - supports fan modes - optionally, if it has a fan which can be configured in different ways:
@@ -40,69 +40,147 @@ namespace climate {
  */
 class ClimateTraits {
  public:
-  bool get_supports_current_temperature() const;
-  void set_supports_current_temperature(bool supports_current_temperature);
-  bool get_supports_two_point_target_temperature() const;
-  void set_supports_two_point_target_temperature(bool supports_two_point_target_temperature);
-  void set_supports_auto_mode(bool supports_auto_mode);
-  void set_supports_cool_mode(bool supports_cool_mode);
-  void set_supports_heat_mode(bool supports_heat_mode);
-  void set_supports_fan_only_mode(bool supports_fan_only_mode);
-  void set_supports_dry_mode(bool supports_dry_mode);
-  void set_supports_away(bool supports_away);
-  bool get_supports_away() const;
-  void set_supports_action(bool supports_action);
-  bool get_supports_action() const;
-  bool supports_mode(ClimateMode mode) const;
-  void set_supports_fan_mode_on(bool supports_fan_mode_on);
-  void set_supports_fan_mode_off(bool supports_fan_mode_off);
-  void set_supports_fan_mode_auto(bool supports_fan_mode_auto);
-  void set_supports_fan_mode_low(bool supports_fan_mode_low);
-  void set_supports_fan_mode_medium(bool supports_fan_mode_medium);
-  void set_supports_fan_mode_high(bool supports_fan_mode_high);
-  void set_supports_fan_mode_middle(bool supports_fan_mode_middle);
-  void set_supports_fan_mode_focus(bool supports_fan_mode_focus);
-  void set_supports_fan_mode_diffuse(bool supports_fan_mode_diffuse);
-  bool supports_fan_mode(ClimateFanMode fan_mode) const;
-  bool get_supports_fan_modes() const;
-  void set_supports_swing_mode_off(bool supports_swing_mode_off);
-  void set_supports_swing_mode_both(bool supports_swing_mode_both);
-  void set_supports_swing_mode_vertical(bool supports_swing_mode_vertical);
-  void set_supports_swing_mode_horizontal(bool supports_swing_mode_horizontal);
-  bool supports_swing_mode(ClimateSwingMode swing_mode) const;
-  bool get_supports_swing_modes() const;
+  bool get_supports_current_temperature() const { return supports_current_temperature_; }
+  void set_supports_current_temperature(bool supports_current_temperature) {
+    supports_current_temperature_ = supports_current_temperature;
+  }
+  bool get_supports_two_point_target_temperature() const { return supports_two_point_target_temperature_; }
+  void set_supports_two_point_target_temperature(bool supports_two_point_target_temperature) {
+    supports_two_point_target_temperature_ = supports_two_point_target_temperature;
+  }
+  void set_supported_modes(std::set<ClimateMode> modes) { supported_modes_ = std::move(modes); }
+  void add_supported_mode(ClimateMode mode) { supported_modes_.insert(mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_auto_mode(bool supports_auto_mode) { set_mode_support_(CLIMATE_MODE_AUTO, supports_auto_mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_cool_mode(bool supports_cool_mode) { set_mode_support_(CLIMATE_MODE_COOL, supports_cool_mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_heat_mode(bool supports_heat_mode) { set_mode_support_(CLIMATE_MODE_HEAT, supports_heat_mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_heat_cool_mode(bool supported) { set_mode_support_(CLIMATE_MODE_HEAT_COOL, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_fan_only_mode(bool supports_fan_only_mode) {
+    set_mode_support_(CLIMATE_MODE_FAN_ONLY, supports_fan_only_mode);
+  }
+  ESPDEPRECATED("This method is deprecated, use set_supported_modes() instead", "v1.20")
+  void set_supports_dry_mode(bool supports_dry_mode) { set_mode_support_(CLIMATE_MODE_DRY, supports_dry_mode); }
+  bool supports_mode(ClimateMode mode) const { return supported_modes_.count(mode); }
+  const std::set<ClimateMode> get_supported_modes() const { return supported_modes_; }
 
-  float get_visual_min_temperature() const;
-  void set_visual_min_temperature(float visual_min_temperature);
-  float get_visual_max_temperature() const;
-  void set_visual_max_temperature(float visual_max_temperature);
-  float get_visual_temperature_step() const;
+  void set_supports_action(bool supports_action) { supports_action_ = supports_action; }
+  bool get_supports_action() const { return supports_action_; }
+
+  void set_supported_fan_modes(std::set<ClimateFanMode> modes) { supported_fan_modes_ = std::move(modes); }
+  void add_supported_fan_mode(ClimateFanMode mode) { supported_fan_modes_.insert(mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_on(bool supported) { set_fan_mode_support_(CLIMATE_FAN_ON, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_off(bool supported) { set_fan_mode_support_(CLIMATE_FAN_OFF, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_auto(bool supported) { set_fan_mode_support_(CLIMATE_FAN_AUTO, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_low(bool supported) { set_fan_mode_support_(CLIMATE_FAN_LOW, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_medium(bool supported) { set_fan_mode_support_(CLIMATE_FAN_MEDIUM, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_high(bool supported) { set_fan_mode_support_(CLIMATE_FAN_HIGH, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_middle(bool supported) { set_fan_mode_support_(CLIMATE_FAN_MIDDLE, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_focus(bool supported) { set_fan_mode_support_(CLIMATE_FAN_FOCUS, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_fan_modes() instead", "v1.20")
+  void set_supports_fan_mode_diffuse(bool supported) { set_fan_mode_support_(CLIMATE_FAN_DIFFUSE, supported); }
+  bool supports_fan_mode(ClimateFanMode fan_mode) const { return supported_fan_modes_.count(fan_mode); }
+  bool get_supports_fan_modes() const { return !supported_fan_modes_.empty() || !supported_custom_fan_modes_.empty(); }
+  const std::set<ClimateFanMode> get_supported_fan_modes() const { return supported_fan_modes_; }
+
+  void set_supported_custom_fan_modes(std::set<std::string> supported_custom_fan_modes) {
+    supported_custom_fan_modes_ = std::move(supported_custom_fan_modes);
+  }
+  const std::set<std::string> &get_supported_custom_fan_modes() const { return supported_custom_fan_modes_; }
+  bool supports_custom_fan_mode(const std::string &custom_fan_mode) const {
+    return supported_custom_fan_modes_.count(custom_fan_mode);
+  }
+
+  void set_supported_presets(std::set<ClimatePreset> presets) { supported_presets_ = std::move(presets); }
+  void add_supported_preset(ClimatePreset preset) { supported_presets_.insert(preset); }
+  bool supports_preset(ClimatePreset preset) const { return supported_presets_.count(preset); }
+  bool get_supports_presets() const { return !supported_presets_.empty(); }
+  const std::set<climate::ClimatePreset> &get_supported_presets() const { return supported_presets_; }
+
+  void set_supported_custom_presets(std::set<std::string> supported_custom_presets) {
+    supported_custom_presets_ = std::move(supported_custom_presets);
+  }
+  const std::set<std::string> &get_supported_custom_presets() const { return supported_custom_presets_; }
+  bool supports_custom_preset(const std::string &custom_preset) const {
+    return supported_custom_presets_.count(custom_preset);
+  }
+  ESPDEPRECATED("This method is deprecated, use set_supported_presets() instead", "v1.20")
+  void set_supports_away(bool supports) {
+    if (supports) {
+      supported_presets_.insert(CLIMATE_PRESET_AWAY);
+      supported_presets_.insert(CLIMATE_PRESET_HOME);
+    }
+  }
+  ESPDEPRECATED("This method is deprecated, use supports_preset() instead", "v1.20")
+  bool get_supports_away() const { return supports_preset(CLIMATE_PRESET_AWAY); }
+
+  void set_supported_swing_modes(std::set<ClimateSwingMode> modes) { supported_swing_modes_ = std::move(modes); }
+  void add_supported_swing_mode(ClimateSwingMode mode) { supported_swing_modes_.insert(mode); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_swing_modes() instead", "v1.20")
+  void set_supports_swing_mode_off(bool supported) { set_swing_mode_support_(CLIMATE_SWING_OFF, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_swing_modes() instead", "v1.20")
+  void set_supports_swing_mode_both(bool supported) { set_swing_mode_support_(CLIMATE_SWING_BOTH, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_swing_modes() instead", "v1.20")
+  void set_supports_swing_mode_vertical(bool supported) { set_swing_mode_support_(CLIMATE_SWING_VERTICAL, supported); }
+  ESPDEPRECATED("This method is deprecated, use set_supported_swing_modes() instead", "v1.20")
+  void set_supports_swing_mode_horizontal(bool supported) {
+    set_swing_mode_support_(CLIMATE_SWING_HORIZONTAL, supported);
+  }
+  bool supports_swing_mode(ClimateSwingMode swing_mode) const { return supported_swing_modes_.count(swing_mode); }
+  bool get_supports_swing_modes() const { return !supported_swing_modes_.empty(); }
+  const std::set<ClimateSwingMode> get_supported_swing_modes() { return supported_swing_modes_; }
+
+  float get_visual_min_temperature() const { return visual_min_temperature_; }
+  void set_visual_min_temperature(float visual_min_temperature) { visual_min_temperature_ = visual_min_temperature; }
+  float get_visual_max_temperature() const { return visual_max_temperature_; }
+  void set_visual_max_temperature(float visual_max_temperature) { visual_max_temperature_ = visual_max_temperature; }
+  float get_visual_temperature_step() const { return visual_temperature_step_; }
   int8_t get_temperature_accuracy_decimals() const;
-  void set_visual_temperature_step(float temperature_step);
+  void set_visual_temperature_step(float temperature_step) { visual_temperature_step_ = temperature_step; }
 
  protected:
+  void set_mode_support_(climate::ClimateMode mode, bool supported) {
+    if (supported) {
+      supported_modes_.insert(mode);
+    } else {
+      supported_modes_.erase(mode);
+    }
+  }
+  void set_fan_mode_support_(climate::ClimateFanMode mode, bool supported) {
+    if (supported) {
+      supported_fan_modes_.insert(mode);
+    } else {
+      supported_fan_modes_.erase(mode);
+    }
+  }
+  void set_swing_mode_support_(climate::ClimateSwingMode mode, bool supported) {
+    if (supported) {
+      supported_swing_modes_.insert(mode);
+    } else {
+      supported_swing_modes_.erase(mode);
+    }
+  }
+
   bool supports_current_temperature_{false};
   bool supports_two_point_target_temperature_{false};
-  bool supports_auto_mode_{false};
-  bool supports_cool_mode_{false};
-  bool supports_heat_mode_{false};
-  bool supports_fan_only_mode_{false};
-  bool supports_dry_mode_{false};
-  bool supports_away_{false};
+  std::set<climate::ClimateMode> supported_modes_ = {climate::CLIMATE_MODE_OFF};
   bool supports_action_{false};
-  bool supports_fan_mode_on_{false};
-  bool supports_fan_mode_off_{false};
-  bool supports_fan_mode_auto_{false};
-  bool supports_fan_mode_low_{false};
-  bool supports_fan_mode_medium_{false};
-  bool supports_fan_mode_high_{false};
-  bool supports_fan_mode_middle_{false};
-  bool supports_fan_mode_focus_{false};
-  bool supports_fan_mode_diffuse_{false};
-  bool supports_swing_mode_off_{false};
-  bool supports_swing_mode_both_{false};
-  bool supports_swing_mode_vertical_{false};
-  bool supports_swing_mode_horizontal_{false};
+  std::set<climate::ClimateFanMode> supported_fan_modes_;
+  std::set<climate::ClimateSwingMode> supported_swing_modes_;
+  std::set<climate::ClimatePreset> supported_presets_;
+  std::set<std::string> supported_custom_fan_modes_;
+  std::set<std::string> supported_custom_presets_;
 
   float visual_min_temperature_{10};
   float visual_max_temperature_{30};

esphome/components/climate_ir/__init__.py

@@ -1,42 +1,55 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.components import climate, remote_transmitter, remote_receiver, sensor, remote_base
+from esphome.components import (
+    climate,
+    remote_transmitter,
+    remote_receiver,
+    sensor,
+    remote_base,
+)
 from esphome.components.remote_base import CONF_RECEIVER_ID, CONF_TRANSMITTER_ID
 from esphome.const import CONF_SUPPORTS_COOL, CONF_SUPPORTS_HEAT, CONF_SENSOR
-from esphome.core import coroutine
 
-AUTO_LOAD = ['sensor', 'remote_base']
-CODEOWNERS = ['@glmnet']
+AUTO_LOAD = ["sensor", "remote_base"]
+CODEOWNERS = ["@glmnet"]
 
-climate_ir_ns = cg.esphome_ns.namespace('climate_ir')
-ClimateIR = climate_ir_ns.class_('ClimateIR', climate.Climate, cg.Component,
-                                 remote_base.RemoteReceiverListener)
+climate_ir_ns = cg.esphome_ns.namespace("climate_ir")
+ClimateIR = climate_ir_ns.class_(
+    "ClimateIR", climate.Climate, cg.Component, remote_base.RemoteReceiverListener
+)
 
-CLIMATE_IR_SCHEMA = climate.CLIMATE_SCHEMA.extend({
-    cv.GenerateID(CONF_TRANSMITTER_ID): cv.use_id(remote_transmitter.RemoteTransmitterComponent),
-    cv.Optional(CONF_SUPPORTS_COOL, default=True): cv.boolean,
-    cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean,
-    cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
-}).extend(cv.COMPONENT_SCHEMA)
+CLIMATE_IR_SCHEMA = climate.CLIMATE_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_TRANSMITTER_ID): cv.use_id(
+            remote_transmitter.RemoteTransmitterComponent
+        ),
+        cv.Optional(CONF_SUPPORTS_COOL, default=True): cv.boolean,
+        cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean,
+        cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
-CLIMATE_IR_WITH_RECEIVER_SCHEMA = CLIMATE_IR_SCHEMA.extend({
-    cv.Optional(CONF_RECEIVER_ID): cv.use_id(remote_receiver.RemoteReceiverComponent),
-})
+CLIMATE_IR_WITH_RECEIVER_SCHEMA = CLIMATE_IR_SCHEMA.extend(
+    {
+        cv.Optional(CONF_RECEIVER_ID): cv.use_id(
+            remote_receiver.RemoteReceiverComponent
+        ),
+    }
+)
 
 
-@coroutine
-def register_climate_ir(var, config):
-    yield cg.register_component(var, config)
-    yield climate.register_climate(var, config)
+async def register_climate_ir(var, config):
+    await cg.register_component(var, config)
+    await climate.register_climate(var, config)
 
     cg.add(var.set_supports_cool(config[CONF_SUPPORTS_COOL]))
     cg.add(var.set_supports_heat(config[CONF_SUPPORTS_HEAT]))
     if CONF_SENSOR in config:
-        sens = yield cg.get_variable(config[CONF_SENSOR])
+        sens = await cg.get_variable(config[CONF_SENSOR])
         cg.add(var.set_sensor(sens))
     if CONF_RECEIVER_ID in config:
-        receiver = yield cg.get_variable(config[CONF_RECEIVER_ID])
+        receiver = await cg.get_variable(config[CONF_RECEIVER_ID])
         cg.add(receiver.register_listener(var))
 
-    transmitter = yield cg.get_variable(config[CONF_TRANSMITTER_ID])
+    transmitter = await cg.get_variable(config[CONF_TRANSMITTER_ID])
     cg.add(var.set_transmitter(transmitter))

esphome/components/climate_ir/climate_ir.cpp

@@ -4,68 +4,27 @@
 namespace esphome {
 namespace climate_ir {
 
-static const char *TAG = "climate_ir";
+static const char *const TAG = "climate_ir";
 
 climate::ClimateTraits ClimateIR::traits() {
   auto traits = climate::ClimateTraits();
   traits.set_supports_current_temperature(this->sensor_ != nullptr);
-  traits.set_supports_auto_mode(true);
-  traits.set_supports_cool_mode(this->supports_cool_);
-  traits.set_supports_heat_mode(this->supports_heat_);
-  traits.set_supports_dry_mode(this->supports_dry_);
-  traits.set_supports_fan_only_mode(this->supports_fan_only_);
+  traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL});
+  if (supports_cool_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
+  if (supports_heat_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
+  if (supports_dry_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_DRY);
+  if (supports_fan_only_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_FAN_ONLY);
+
   traits.set_supports_two_point_target_temperature(false);
-  traits.set_supports_away(false);
   traits.set_visual_min_temperature(this->minimum_temperature_);
   traits.set_visual_max_temperature(this->maximum_temperature_);
   traits.set_visual_temperature_step(this->temperature_step_);
-  for (auto fan_mode : this->fan_modes_) {
-    switch (fan_mode) {
-      case climate::CLIMATE_FAN_AUTO:
-        traits.set_supports_fan_mode_auto(true);
-        break;
-      case climate::CLIMATE_FAN_DIFFUSE:
-        traits.set_supports_fan_mode_diffuse(true);
-        break;
-      case climate::CLIMATE_FAN_FOCUS:
-        traits.set_supports_fan_mode_focus(true);
-        break;
-      case climate::CLIMATE_FAN_HIGH:
-        traits.set_supports_fan_mode_high(true);
-        break;
-      case climate::CLIMATE_FAN_LOW:
-        traits.set_supports_fan_mode_low(true);
-        break;
-      case climate::CLIMATE_FAN_MEDIUM:
-        traits.set_supports_fan_mode_medium(true);
-        break;
-      case climate::CLIMATE_FAN_MIDDLE:
-        traits.set_supports_fan_mode_middle(true);
-        break;
-      case climate::CLIMATE_FAN_OFF:
-        traits.set_supports_fan_mode_off(true);
-        break;
-      case climate::CLIMATE_FAN_ON:
-        traits.set_supports_fan_mode_on(true);
-        break;
-    }
-  }
-  for (auto swing_mode : this->swing_modes_) {
-    switch (swing_mode) {
-      case climate::CLIMATE_SWING_OFF:
-        traits.set_supports_swing_mode_off(true);
-        break;
-      case climate::CLIMATE_SWING_BOTH:
-        traits.set_supports_swing_mode_both(true);
-        break;
-      case climate::CLIMATE_SWING_VERTICAL:
-        traits.set_supports_swing_mode_vertical(true);
-        break;
-      case climate::CLIMATE_SWING_HORIZONTAL:
-        traits.set_supports_swing_mode_horizontal(true);
-        break;
-    }
-  }
+  traits.set_supported_fan_modes(fan_modes_);
+  traits.set_supported_swing_modes(swing_modes_);
   return traits;
 }
 

esphome/components/climate_ir/climate_ir.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/remote_base/remote_base.h"
 #include "esphome/components/remote_transmitter/remote_transmitter.h"
@@ -19,16 +21,15 @@ namespace climate_ir {
 class ClimateIR : public climate::Climate, public Component, public remote_base::RemoteReceiverListener {
  public:
   ClimateIR(float minimum_temperature, float maximum_temperature, float temperature_step = 1.0f,
-            bool supports_dry = false, bool supports_fan_only = false,
-            std::vector<climate::ClimateFanMode> fan_modes = {},
-            std::vector<climate::ClimateSwingMode> swing_modes = {}) {
+            bool supports_dry = false, bool supports_fan_only = false, std::set<climate::ClimateFanMode> fan_modes = {},
+            std::set<climate::ClimateSwingMode> swing_modes = {}) {
     this->minimum_temperature_ = minimum_temperature;
     this->maximum_temperature_ = maximum_temperature;
     this->temperature_step_ = temperature_step;
     this->supports_dry_ = supports_dry;
     this->supports_fan_only_ = supports_fan_only;
-    this->fan_modes_ = fan_modes;
-    this->swing_modes_ = swing_modes;
+    this->fan_modes_ = std::move(fan_modes);
+    this->swing_modes_ = std::move(swing_modes);
   }
 
   void setup() override;
@@ -58,8 +59,8 @@ class ClimateIR : public climate::Climate, public Component, public remote_base:
   bool supports_heat_{true};
   bool supports_dry_{false};
   bool supports_fan_only_{false};
-  std::vector<climate::ClimateFanMode> fan_modes_ = {};
-  std::vector<climate::ClimateSwingMode> swing_modes_ = {};
+  std::set<climate::ClimateFanMode> fan_modes_ = {};
+  std::set<climate::ClimateSwingMode> swing_modes_ = {};
 
   remote_transmitter::RemoteTransmitterComponent *transmitter_;
   sensor::Sensor *sensor_{nullptr};

esphome/components/climate_ir_lg/climate.py

@@ -3,16 +3,45 @@ import esphome.config_validation as cv
 from esphome.components import climate_ir
 from esphome.const import CONF_ID
 
-AUTO_LOAD = ['climate_ir']
+AUTO_LOAD = ["climate_ir"]
 
-climate_ir_lg_ns = cg.esphome_ns.namespace('climate_ir_lg')
-LgIrClimate = climate_ir_lg_ns.class_('LgIrClimate', climate_ir.ClimateIR)
+climate_ir_lg_ns = cg.esphome_ns.namespace("climate_ir_lg")
+LgIrClimate = climate_ir_lg_ns.class_("LgIrClimate", climate_ir.ClimateIR)
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(LgIrClimate),
-})
+CONF_HEADER_HIGH = "header_high"
+CONF_HEADER_LOW = "header_low"
+CONF_BIT_HIGH = "bit_high"
+CONF_BIT_ONE_LOW = "bit_one_low"
+CONF_BIT_ZERO_LOW = "bit_zero_low"
+
+CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(LgIrClimate),
+        cv.Optional(
+            CONF_HEADER_HIGH, default="8000us"
+        ): cv.positive_time_period_microseconds,
+        cv.Optional(
+            CONF_HEADER_LOW, default="4000us"
+        ): cv.positive_time_period_microseconds,
+        cv.Optional(
+            CONF_BIT_HIGH, default="600us"
+        ): cv.positive_time_period_microseconds,
+        cv.Optional(
+            CONF_BIT_ONE_LOW, default="1600us"
+        ): cv.positive_time_period_microseconds,
+        cv.Optional(
+            CONF_BIT_ZERO_LOW, default="550us"
+        ): cv.positive_time_period_microseconds,
+    }
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield climate_ir.register_climate_ir(var, config)
+    await climate_ir.register_climate_ir(var, config)
+
+    cg.add(var.set_header_high(config[CONF_HEADER_HIGH]))
+    cg.add(var.set_header_low(config[CONF_HEADER_LOW]))
+    cg.add(var.set_bit_high(config[CONF_BIT_HIGH]))
+    cg.add(var.set_bit_one_low(config[CONF_BIT_ONE_LOW]))
+    cg.add(var.set_bit_zero_low(config[CONF_BIT_ZERO_LOW]))

esphome/components/climate_ir_lg/climate_ir_lg.cpp

@@ -4,11 +4,12 @@
 namespace esphome {
 namespace climate_ir_lg {
 
-static const char *TAG = "climate.climate_ir_lg";
+static const char *const TAG = "climate.climate_ir_lg";
 
 const uint32_t COMMAND_ON = 0x00000;
 const uint32_t COMMAND_ON_AI = 0x03000;
 const uint32_t COMMAND_COOL = 0x08000;
+const uint32_t COMMAND_HEAT = 0x0C000;
 const uint32_t COMMAND_OFF = 0xC0000;
 const uint32_t COMMAND_SWING = 0x10000;
 // On, 25C, Mode: Auto, Fan: Auto, Zone Follow: Off, Sensor Temp: Ignore.
@@ -28,13 +29,6 @@ const uint8_t TEMP_RANGE = TEMP_MAX - TEMP_MIN + 1;
 const uint32_t TEMP_MASK = 0XF00;
 const uint32_t TEMP_SHIFT = 8;
 
-// Constants
-static const uint32_t HEADER_HIGH_US = 8000;
-static const uint32_t HEADER_LOW_US = 4000;
-static const uint32_t BIT_HIGH_US = 600;
-static const uint32_t BIT_ONE_LOW_US = 1600;
-static const uint32_t BIT_ZERO_LOW_US = 550;
-
 const uint16_t BITS = 28;
 
 void LgIrClimate::transmit_state() {
@@ -45,7 +39,7 @@ void LgIrClimate::transmit_state() {
     send_swing_cmd_ = false;
     remote_state |= COMMAND_SWING;
   } else {
-    if (mode_before_ == climate::CLIMATE_MODE_OFF && this->mode == climate::CLIMATE_MODE_AUTO) {
+    if (mode_before_ == climate::CLIMATE_MODE_OFF && this->mode == climate::CLIMATE_MODE_HEAT_COOL) {
       remote_state |= COMMAND_ON_AI;
     } else if (mode_before_ == climate::CLIMATE_MODE_OFF && this->mode != climate::CLIMATE_MODE_OFF) {
       remote_state |= COMMAND_ON;
@@ -55,7 +49,10 @@ void LgIrClimate::transmit_state() {
         case climate::CLIMATE_MODE_COOL:
           remote_state |= COMMAND_COOL;
           break;
-        case climate::CLIMATE_MODE_AUTO:
+        case climate::CLIMATE_MODE_HEAT:
+          remote_state |= COMMAND_HEAT;
+          break;
+        case climate::CLIMATE_MODE_HEAT_COOL:
           remote_state |= COMMAND_AUTO;
           break;
         case climate::CLIMATE_MODE_DRY:
@@ -73,8 +70,9 @@ void LgIrClimate::transmit_state() {
 
     if (this->mode == climate::CLIMATE_MODE_OFF) {
       remote_state |= FAN_AUTO;
-    } else if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_DRY) {
-      switch (this->fan_mode) {
+    } else if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_DRY ||
+               this->mode == climate::CLIMATE_MODE_HEAT) {
+      switch (this->fan_mode.value()) {
         case climate::CLIMATE_FAN_HIGH:
           remote_state |= FAN_MAX;
           break;
@@ -91,12 +89,12 @@ void LgIrClimate::transmit_state() {
       }
     }
 
-    if (this->mode == climate::CLIMATE_MODE_AUTO) {
+    if (this->mode == climate::CLIMATE_MODE_HEAT_COOL) {
       this->fan_mode = climate::CLIMATE_FAN_AUTO;
       // remote_state |= FAN_MODE_AUTO_DRY;
     }
-    if (this->mode == climate::CLIMATE_MODE_COOL) {
-      auto temp = (uint8_t) roundf(clamp(this->target_temperature, TEMP_MIN, TEMP_MAX));
+    if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT) {
+      auto temp = (uint8_t) roundf(clamp<float>(this->target_temperature, TEMP_MIN, TEMP_MAX));
       remote_state |= ((temp - 15) << TEMP_SHIFT);
     }
   }
@@ -108,13 +106,13 @@ bool LgIrClimate::on_receive(remote_base::RemoteReceiveData data) {
   uint8_t nbits = 0;
   uint32_t remote_state = 0;
 
-  if (!data.expect_item(HEADER_HIGH_US, HEADER_LOW_US))
+  if (!data.expect_item(this->header_high_, this->header_low_))
     return false;
 
   for (nbits = 0; nbits < 32; nbits++) {
-    if (data.expect_item(BIT_HIGH_US, BIT_ONE_LOW_US)) {
+    if (data.expect_item(this->bit_high_, this->bit_one_low_)) {
       remote_state = (remote_state << 1) | 1;
-    } else if (data.expect_item(BIT_HIGH_US, BIT_ZERO_LOW_US)) {
+    } else if (data.expect_item(this->bit_high_, this->bit_zero_low_)) {
       remote_state = (remote_state << 1) | 0;
     } else if (nbits == BITS) {
       break;
@@ -130,7 +128,7 @@ bool LgIrClimate::on_receive(remote_base::RemoteReceiveData data) {
   if ((remote_state & COMMAND_MASK) == COMMAND_ON) {
     this->mode = climate::CLIMATE_MODE_COOL;
   } else if ((remote_state & COMMAND_MASK) == COMMAND_ON_AI) {
-    this->mode = climate::CLIMATE_MODE_AUTO;
+    this->mode = climate::CLIMATE_MODE_HEAT_COOL;
   }
 
   if ((remote_state & COMMAND_MASK) == COMMAND_OFF) {
@@ -140,30 +138,33 @@ bool LgIrClimate::on_receive(remote_base::RemoteReceiveData data) {
         this->swing_mode == climate::CLIMATE_SWING_OFF ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF;
   } else {
     if ((remote_state & COMMAND_MASK) == COMMAND_AUTO)
-      this->mode = climate::CLIMATE_MODE_AUTO;
-    else if ((remote_state & COMMAND_MASK) == COMMAND_DRY_FAN) {
+      this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+    else if ((remote_state & COMMAND_MASK) == COMMAND_DRY_FAN)
       this->mode = climate::CLIMATE_MODE_DRY;
+    else if ((remote_state & COMMAND_MASK) == COMMAND_HEAT) {
+      this->mode = climate::CLIMATE_MODE_HEAT;
     } else {
       this->mode = climate::CLIMATE_MODE_COOL;
     }
-  }
 
-  // Temperature
-  if (this->mode == climate::CLIMATE_MODE_COOL)
-    this->target_temperature = ((remote_state & TEMP_MASK) >> TEMP_SHIFT) + 15;
+    // Temperature
+    if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT)
+      this->target_temperature = ((remote_state & TEMP_MASK) >> TEMP_SHIFT) + 15;
 
-  // Fan Speed
-  if (this->mode == climate::CLIMATE_MODE_AUTO) {
-    this->fan_mode = climate::CLIMATE_FAN_AUTO;
-  } else if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_DRY) {
-    if ((remote_state & FAN_MASK) == FAN_AUTO)
+    // Fan Speed
+    if (this->mode == climate::CLIMATE_MODE_HEAT_COOL) {
       this->fan_mode = climate::CLIMATE_FAN_AUTO;
-    else if ((remote_state & FAN_MASK) == FAN_MIN)
-      this->fan_mode = climate::CLIMATE_FAN_LOW;
-    else if ((remote_state & FAN_MASK) == FAN_MED)
-      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
-    else if ((remote_state & FAN_MASK) == FAN_MAX)
-      this->fan_mode = climate::CLIMATE_FAN_HIGH;
+    } else if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT ||
+               this->mode == climate::CLIMATE_MODE_DRY) {
+      if ((remote_state & FAN_MASK) == FAN_AUTO)
+        this->fan_mode = climate::CLIMATE_FAN_AUTO;
+      else if ((remote_state & FAN_MASK) == FAN_MIN)
+        this->fan_mode = climate::CLIMATE_FAN_LOW;
+      else if ((remote_state & FAN_MASK) == FAN_MED)
+        this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      else if ((remote_state & FAN_MASK) == FAN_MAX)
+        this->fan_mode = climate::CLIMATE_FAN_HIGH;
+    }
   }
   this->publish_state();
 
@@ -179,15 +180,16 @@ void LgIrClimate::transmit_(uint32_t value) {
   data->set_carrier_frequency(38000);
   data->reserve(2 + BITS * 2u);
 
-  data->item(HEADER_HIGH_US, HEADER_LOW_US);
+  data->item(this->header_high_, this->header_low_);
 
   for (uint32_t mask = 1UL << (BITS - 1); mask != 0; mask >>= 1) {
-    if (value & mask)
-      data->item(BIT_HIGH_US, BIT_ONE_LOW_US);
-    else
-      data->item(BIT_HIGH_US, BIT_ZERO_LOW_US);
+    if (value & mask) {
+      data->item(this->bit_high_, this->bit_one_low_);
+    } else {
+      data->item(this->bit_high_, this->bit_zero_low_);
+    }
   }
-  data->mark(BIT_HIGH_US);
+  data->mark(this->bit_high_);
   transmit.perform();
 }
 void LgIrClimate::calc_checksum_(uint32_t &value) {

esphome/components/climate_ir_lg/climate_ir_lg.h

@@ -25,6 +25,11 @@ class LgIrClimate : public climate_ir::ClimateIR {
       this->swing_mode = climate::CLIMATE_SWING_OFF;
     climate_ir::ClimateIR::control(call);
   }
+  void set_header_high(uint32_t header_high) { this->header_high_ = header_high; }
+  void set_header_low(uint32_t header_low) { this->header_low_ = header_low; }
+  void set_bit_high(uint32_t bit_high) { this->bit_high_ = bit_high; }
+  void set_bit_one_low(uint32_t bit_one_low) { this->bit_one_low_ = bit_one_low; }
+  void set_bit_zero_low(uint32_t bit_zero_low) { this->bit_zero_low_ = bit_zero_low; }
 
  protected:
   /// Transmit via IR the state of this climate controller.
@@ -37,6 +42,12 @@ class LgIrClimate : public climate_ir::ClimateIR {
   void calc_checksum_(uint32_t &value);
   void transmit_(uint32_t value);
 
+  uint32_t header_high_;
+  uint32_t header_low_;
+  uint32_t bit_high_;
+  uint32_t bit_one_low_;
+  uint32_t bit_zero_low_;
+
   climate::ClimateMode mode_before_{climate::CLIMATE_MODE_OFF};
 };
 

esphome/components/color/__init__.py

@@ -2,22 +2,56 @@ from esphome import config_validation as cv
 from esphome import codegen as cg
 from esphome.const import CONF_BLUE, CONF_GREEN, CONF_ID, CONF_RED, CONF_WHITE
 
-ColorStruct = cg.esphome_ns.struct('Color')
+ColorStruct = cg.esphome_ns.struct("Color")
 
 MULTI_CONF = True
-CONFIG_SCHEMA = cv.Schema({
-    cv.Required(CONF_ID): cv.declare_id(ColorStruct),
-    cv.Optional(CONF_RED, default=0.0): cv.percentage,
-    cv.Optional(CONF_GREEN, default=0.0): cv.percentage,
-    cv.Optional(CONF_BLUE, default=0.0): cv.percentage,
-    cv.Optional(CONF_WHITE, default=0.0): cv.percentage,
-}).extend(cv.COMPONENT_SCHEMA)
+
+CONF_RED_INT = "red_int"
+CONF_GREEN_INT = "green_int"
+CONF_BLUE_INT = "blue_int"
+CONF_WHITE_INT = "white_int"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.declare_id(ColorStruct),
+        cv.Exclusive(CONF_RED, "red"): cv.percentage,
+        cv.Exclusive(CONF_RED_INT, "red"): cv.uint8_t,
+        cv.Exclusive(CONF_GREEN, "green"): cv.percentage,
+        cv.Exclusive(CONF_GREEN_INT, "green"): cv.uint8_t,
+        cv.Exclusive(CONF_BLUE, "blue"): cv.percentage,
+        cv.Exclusive(CONF_BLUE_INT, "blue"): cv.uint8_t,
+        cv.Exclusive(CONF_WHITE, "white"): cv.percentage,
+        cv.Exclusive(CONF_WHITE_INT, "white"): cv.uint8_t,
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
-def to_code(config):
-    cg.variable(config[CONF_ID], cg.StructInitializer(
-        ColorStruct,
-        ('r', config[CONF_RED]),
-        ('g', config[CONF_GREEN]),
-        ('b', config[CONF_BLUE]),
-        ('w', config[CONF_WHITE])))
+async def to_code(config):
+    r = 0
+    if CONF_RED in config:
+        r = int(config[CONF_RED] * 255)
+    elif CONF_RED_INT in config:
+        r = config[CONF_RED_INT]
+
+    g = 0
+    if CONF_GREEN in config:
+        g = int(config[CONF_GREEN] * 255)
+    elif CONF_GREEN_INT in config:
+        g = config[CONF_GREEN_INT]
+
+    b = 0
+    if CONF_BLUE in config:
+        b = int(config[CONF_BLUE] * 255)
+    elif CONF_BLUE_INT in config:
+        b = config[CONF_BLUE_INT]
+
+    w = 0
+    if CONF_WHITE in config:
+        w = int(config[CONF_WHITE] * 255)
+    elif CONF_WHITE_INT in config:
+        w = config[CONF_WHITE_INT]
+
+    cg.new_variable(
+        config[CONF_ID],
+        cg.StructInitializer(ColorStruct, ("r", r), ("g", g), ("b", b), ("w", w)),
+    )