Merge pull request #3596 from esphome/bump-2022.6.2

2022.6.2

.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

@@ -2,17 +2,29 @@
 Checks: >-
   *,
   -abseil-*,
+  -altera-*,
   -android-*,
   -boost-*,
-  -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
+  -bugprone-signed-char-misuse,
   -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.*,
-  -cppcoreguidelines-avoid-goto,
-  -cppcoreguidelines-c-copy-assignment-signature,
-  -cppcoreguidelines-owning-memory,
+  -clang-diagnostic-delete-abstract-non-virtual-dtor,
+  -clang-diagnostic-delete-non-abstract-non-virtual-dtor,
+  -clang-diagnostic-shadow-field,
+  -clang-diagnostic-unused-const-variable,
+  -clang-diagnostic-unused-parameter,
+  -concurrency-*,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
@@ -24,42 +36,49 @@ 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-namespace-comments,
   -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-avoid-bind,
+  -modernize-concat-nested-namespaces,
   -modernize-return-braced-init-list,
   -modernize-use-auto,
   -modernize-use-default-member-init,
   -modernize-use-equals-default,
+  -modernize-use-trailing-return-type,
+  -modernize-use-nodiscard,
   -mpi-*,
   -objc-*,
-  -performance-unnecessary-value-param,
-  -readability-braces-around-statements,
+  -readability-convert-member-functions-to-static,
   -readability-else-after-return,
+  -readability-function-cognitive-complexity,
   -readability-implicit-bool-conversion,
-  -readability-named-parameter,
-  -readability-redundant-member-init,
-  -warnings-as-errors,
-  -zircon-*
+  -readability-isolate-declaration,
+  -readability-magic-numbers,
+  -readability-make-member-function-const,
+  -readability-redundant-string-init,
+  -readability-uppercase-literal-suffix,
+  -readability-use-anyofallof,
 WarningsAsErrors: '*'
-HeaderFilterRegex: '^.*/src/esphome/.*'
 AnalyzeTemporaryDtors: false
 FormatStyle:     google
 CheckOptions:
@@ -67,9 +86,11 @@ CheckOptions:
     value:           '1'
   - key:             google-readability-function-size.StatementThreshold
     value:           '800'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
+  - key:             google-runtime-int.TypeSuffix
+    value:           '_t'
+  - key:             llvm-namespace-comment.ShortNamespaceLines
     value:           '10'
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
+  - key:             llvm-namespace-comment.SpacesBeforeComments
     value:           '2'
   - key:             modernize-loop-convert.MaxCopySize
     value:           '16'
@@ -83,6 +104,12 @@ CheckOptions:
     value:           llvm
   - key:             modernize-use-nullptr.NullMacros
     value:           'NULL'
+  - key:             modernize-make-unique.MakeSmartPtrFunction
+    value:           'make_unique'
+  - key:             modernize-make-unique.MakeSmartPtrFunctionHeader
+    value:           'esphome/core/helpers.h'
+  - key:             readability-braces-around-statements.ShortStatementLines
+    value:           2
   - key:             readability-identifier-naming.LocalVariableCase
     value:           'lower_case'
   - key:             readability-identifier-naming.ClassCase
@@ -96,15 +123,19 @@ CheckOptions:
   - key:             readability-identifier-naming.StaticConstantCase
     value:           'UPPER_CASE'
   - key:             readability-identifier-naming.StaticVariableCase
-    value:           'UPPER_CASE'
+    value:           'lower_case'
   - key:             readability-identifier-naming.GlobalConstantCase
     value:           'UPPER_CASE'
   - key:             readability-identifier-naming.ParameterCase
     value:           'lower_case'
-  - key:             readability-identifier-naming.PrivateMemberPrefix
-    value:           'NO_PRIVATE_MEMBERS_ALWAYS_USE_PROTECTED'
-  - key:             readability-identifier-naming.PrivateMethodPrefix
-    value:           'NO_PRIVATE_METHODS_ALWAYS_USE_PROTECTED'
+  - key:             readability-identifier-naming.PrivateMemberCase
+    value:           'lower_case'
+  - key:             readability-identifier-naming.PrivateMemberSuffix
+    value:           '_'
+  - key:             readability-identifier-naming.PrivateMethodCase
+    value:           'lower_case'
+  - key:             readability-identifier-naming.PrivateMethodSuffix
+    value:           '_'
   - key:             readability-identifier-naming.ClassMemberCase
     value:           'lower_case'
   - key:             readability-identifier-naming.ClassMemberCase
@@ -125,3 +156,5 @@ CheckOptions:
     value:           'lower_case'
   - key:             readability-identifier-naming.VirtualMethodSuffix
     value:           ''
+  - key:             readability-qualified-auto.AddConstToQualified
+    value:           0

.devcontainer/devcontainer.json

@@ -1,17 +1,29 @@
 {
   "name": "ESPHome Dev",
-  "context": "..",
-  "dockerFile": "../docker/Dockerfile.dev",
-  "postCreateCommand": "mkdir -p config && pip3 install -e .",
-  "runArgs": ["--privileged", "-e", "ESPHOME_DASHBOARD_USE_PING=1"],
+  "image": "esphome/esphome-lint:dev",
+  "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 +31,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 +39,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
+

.gitattributes

@@ -0,0 +1,2 @@
+# Normalize line endings to LF in the repository
+* text eol=lf

.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/ISSUE_TEMPLATE/config.yml

@@ -9,4 +9,3 @@ contact_links:
   - name: Frequently Asked Question
     url: https://esphome.io/guides/faq.html
     about: Please view the FAQ for common questions and what to include in a bug report.
-    

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,10 +1,37 @@
-## 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
+- [ ] ESP32 IDF
+- [ ] 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).

.github/issue-close-app.yml

@@ -1,7 +0,0 @@
-comment: >-
-  https://github.com/esphome/esphome/issues/430
-issueConfigs:
-- content:
-  - "OTHERWISE THE ISSUE WILL BE CLOSED AUTOMATICALLY"
-
-caseInsensitive: false

.github/lock.yml

@@ -1,36 +0,0 @@
-# Configuration for Lock Threads - https://github.com/dessant/lock-threads
-
-# Number of days of inactivity before a closed issue or pull request is locked
-daysUntilLock: 7
-
-# Skip issues and pull requests created before a given timestamp. Timestamp must
-# follow ISO 8601 (`YYYY-MM-DD`). Set to `false` to disable
-skipCreatedBefore: false
-
-# Issues and pull requests with these labels will be ignored. Set to `[]` to disable
-exemptLabels:
-  - keep-open
-
-# Label to add before locking, such as `outdated`. Set to `false` to disable
-lockLabel: false
-
-# Comment to post before locking. Set to `false` to disable
-lockComment: false
-
-# Assign `resolved` as the reason for locking. Set to `false` to disable
-setLockReason: false
-
-# Limit to only `issues` or `pulls`
-# only: issues
-
-# Optionally, specify configuration settings just for `issues` or `pulls`
-# issues:
-#   exemptLabels:
-#     - help-wanted
-#   lockLabel: outdated
-
-# pulls:
-#   daysUntilLock: 30
-
-# Repository to extend settings from
-# _extends: repo

.github/stale.yml

@@ -1,59 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 60
-
-# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
-# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
-daysUntilClose: 7
-
-# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
-onlyLabels: []
-
-# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
-exemptLabels:
-  - not-stale
-
-# Set to true to ignore issues in a project (defaults to false)
-exemptProjects: false
-
-# Set to true to ignore issues in a milestone (defaults to false)
-exemptMilestones: true
-
-# Set to true to ignore issues with an assignee (defaults to false)
-exemptAssignees: false
-
-# Label to use when marking as stale
-staleLabel: stale
-
-# Comment to post when marking as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs. Thank you
-  for your contributions.
-
-# Comment to post when removing the stale label.
-# unmarkComment: >
-#   Your comment here.
-
-# Comment to post when closing a stale Issue or Pull Request.
-# closeComment: >
-#   Your comment here.
-
-# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 10
-
-# Limit to only `issues` or `pulls`
-only: pulls
-
-# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
-# pulls:
-#   daysUntilStale: 30
-#   markComment: >
-#     This pull request has been automatically marked as stale because it has not had
-#     recent activity. It will be closed if no further activity occurs. Thank you
-#     for your contributions.
-
-# issues:
-#   exemptLabels:
-#     - confirmed

.github/workflows/ci-docker.yml

@@ -3,15 +3,23 @@ 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/**'
+      - 'requirements*.txt'
+      - 'platformio.ini'
 
   pull_request:
     paths:
       - 'docker/**'
       - '.github/workflows/**'
+      - 'requirements*.txt'
+      - 'platformio.ini'
+
+permissions:
+  contents: read
+  packages: read
 
 jobs:
   check-docker:
@@ -20,35 +28,26 @@ 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.3.4"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v1
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v1
 
-          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: Set TAG
+      run: |
+        echo "TAG=check" >> $GITHUB_ENV
 
-          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

@@ -1,215 +1,166 @@
-# THESE JOBS ARE COPIED IN release.yml and release-dev.yml
-# PLEASE ALSO UPDATE THOSE FILES WHEN CHANGING LINES HERE
 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:
 
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  # A fast overview job that checks only changed files
-  overview:
+  ci:
+    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]
-    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
+        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
+            pio_cache_key: test1
+          - id: test
+            file: tests/test2.yaml
+            name: Test tests/test2.yaml
+            pio_cache_key: test2
+          - id: test
+            file: tests/test3.yaml
+            name: Test tests/test3.yaml
+            pio_cache_key: test3
+          - id: test
+            file: tests/test4.yaml
+            name: Test tests/test4.yaml
+            pio_cache_key: test4
+          - id: test
+            file: tests/test5.yaml
+            name: Test tests/test5.yaml
+            pio_cache_key: test5
+          - id: pytest
+            name: Run pytest
+          - id: clang-format
+            name: Run script/clang-format
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP8266
+            options: --environment esp8266-arduino-tidy --grep USE_ESP8266
+            pio_cache_key: tidyesp8266
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP32 Arduino 1/4
+            options: --environment esp32-arduino-tidy --split-num 4 --split-at 1
+            pio_cache_key: tidyesp32
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP32 Arduino 2/4
+            options: --environment esp32-arduino-tidy --split-num 4 --split-at 2
+            pio_cache_key: tidyesp32
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP32 Arduino 3/4
+            options: --environment esp32-arduino-tidy --split-num 4 --split-at 3
+            pio_cache_key: tidyesp32
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP32 Arduino 4/4
+            options: --environment esp32-arduino-tidy --split-num 4 --split-at 4
+            pio_cache_key: tidyesp32
+          - id: clang-tidy
+            name: Run script/clang-tidy for ESP32 IDF
+            options: --environment esp32-idf-tidy --grep USE_ESP_IDF
+            pio_cache_key: tidyesp32-idf
 
-
-      - 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
+        id: python
         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
+          python-version: '3.8'
 
-      - name: Register problem matchers
+      - name: Cache virtualenv
+        uses: actions/cache@v2
+        with:
+          path: .venv
+          key: venv-${{ steps.python.outputs.python-version }}-${{ hashFiles('requirements*.txt') }}
+          restore-keys: |
+            venv-${{ steps.python.outputs.python-version }}-
+
+      - name: Set up virtualenv
         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
+          python -m venv .venv
+          source .venv/bin/activate
+          pip install -U pip
+          pip install -r requirements.txt -r requirements_optional.txt -r requirements_test.txt
+          pip install -e .
+          echo "$GITHUB_WORKSPACE/.venv/bin" >> $GITHUB_PATH
+          echo "VIRTUAL_ENV=$GITHUB_WORKSPACE/.venv" >> $GITHUB_ENV
 
-  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
+      # Use per check platformio cache because checks use different parts
+      - name: Cache platformio
+        uses: actions/cache@v2
         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
+          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}
+        if: matrix.id == 'test' || matrix.id == 'clang-tidy'
 
+      - name: Install clang tools
+        run: |
+          sudo apt-get install \
+              clang-format-11 \
+              clang-tidy-11
+        if: matrix.id == 'clang-tidy' || matrix.id == 'clang-format'
 
       - 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
+          echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
 
-  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'
+        env:
+          # Also cache libdeps, store them in a ~/.platformio subfolder
+          PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps
+
       - name: Run pytest
         run: |
-          pytest \
-            -qq \
-            --durations=10 \
-            -o console_output_style=count \
-            tests
+          pytest -vv --tb=native tests
+        if: matrix.id == 'pytest'
+
+      # 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 ${{ matrix.options }}
+        if: matrix.id == 'clang-tidy'
+        env:
+          # Also cache libdeps, store them in a ~/.platformio subfolder
+          PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps
+
+      - name: Suggested changes
+        run: script/ci-suggest-changes
+        if: always() && (matrix.id == 'clang-tidy' || matrix.id == 'clang-format')

.github/workflows/lock.yml

@@ -0,0 +1,27 @@
+name: Lock
+
+on:
+  schedule:
+    - cron: '30 0 * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v3
+        with:
+          pr-inactive-days: "1"
+          pr-lock-reason: ""
+          exclude-any-pr-labels: keep-open
+
+          issue-inactive-days: "7"
+          issue-lock-reason: ""
+          exclude-any-issue-labels: keep-open

.github/workflows/matchers/ci-custom.json

@@ -4,7 +4,7 @@
             "owner": "ci-custom",
             "pattern": [
                 {
-                    "regexp": "^ERROR (.*):(\\d+):(\\d+) - (.*)$",
+                    "regexp": "^(.*):(\\d+):(\\d+):\\s+lint:\\s+(.*)$",
                     "file": 1,
                     "line": 2,
                     "column": 3,

.github/workflows/matchers/gcc.json

@@ -5,7 +5,7 @@
       "severity": "error",
       "pattern": [
         {
-          "regexp": "^(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
+          "regexp": "^src/(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
           "file": 1,
           "line": 2,
           "column": 3,

.github/workflows/matchers/lint-python.json

@@ -1,11 +1,22 @@
 {
   "problemMatcher": [
+    {
+      "owner": "black",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*): (Please format this file with the black formatter)",
+          "file": 1,
+          "message": 2
+        }
+      ]
+    },
     {
       "owner": "flake8",
       "severity": "error",
       "pattern": [
           {
-          "regexp": "^(.*):(\\d+) - ([EFCDNW]\\d{3}.*)$",
+          "regexp": "^(.*):(\\d+): ([EFCDNW]\\d{3}.*)$",
           "file": 1,
           "line": 2,
           "message": 3
@@ -17,7 +28,7 @@
       "severity": "error",
       "pattern": [
         {
-          "regexp": "^(.*):(\\d+) - (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
+          "regexp": "^(.*):(\\d+): (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
           "file": 1,
           "line": 2,
           "message": 3

.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.3.4"
-
-          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,38 @@
 name: Publish Release
 
 on:
+  workflow_dispatch:
   release:
     types: [published]
+  schedule:
+    - cron: "0 2 * * *"
+
+permissions:
+  contents: read
 
 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/}"
+          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
@@ -196,107 +55,100 @@ jobs:
   deploy-docker:
     name: Build and publish docker containers
     if: github.repository == 'esphome/esphome'
+    permissions:
+      contents: read
+      packages: write
     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", "lint"]
     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.3.4"
+    - 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: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v1
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v1
 
-          # 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}"
-      - name: Pull for cache
-        run: |
-          docker pull "${BUILD_TO}:latest" || 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}:latest" \
-            --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}"
+    - 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 }}
 
-      # 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: Build and push
+      run: |
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build \
+          --push
 
   deploy-docker-manifest:
     if: github.repository == 'esphome/esphome'
+    permissions:
+      contents: read
+      packages: write
     runs-on: ubuntu-latest
-    needs: [deploy-docker]
+    needs: [init, deploy-docker]
+    strategy:
+      matrix:
+        build_type: ["ha-addon", "docker", "lint"]
     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
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --build-type "${{ matrix.build_type }}" \
+          manifest
 
-    - 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
+  deploy-ha-addon-repo:
+    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
+    runs-on: ubuntu-latest
+    needs: [deploy-docker]
+    steps:
+      - env:
+          TOKEN: ${{ secrets.DEPLOY_HA_ADDON_REPO_TOKEN }}
+        run: |
+          TAG="${GITHUB_REF#refs/tags/}"
+          curl \
+            -u ":$TOKEN" \
+            -X POST \
+            -H "Accept: application/vnd.github.v3+json" \
+            https://api.github.com/repos/esphome/home-assistant-addon/actions/workflows/bump-version.yml/dispatches \
+            -d "{\"ref\":\"main\",\"inputs\":{\"version\":\"$TAG\"}}"

.github/workflows/stale.yml

@@ -0,0 +1,48 @@
+name: Stale
+
+on:
+  schedule:
+    - cron: '30 0 * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v4
+        with:
+          days-before-pr-stale: 90
+          days-before-pr-close: 7
+          days-before-issue-stale: -1
+          days-before-issue-close: -1
+          remove-stale-when-updated: true
+          stale-pr-label: "stale"
+          exempt-pr-labels: "no-stale"
+          stale-pr-message: >
+            There hasn't been any activity on this pull request recently. This
+            pull request has been automatically marked as stale because of that
+            and will be closed if no further activity occurs within 7 days.
+            Thank you for your contributions.
+
+  # Use stale to automatically close issues with a reference to the issue tracker
+  close-issues:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v4
+        with:
+          days-before-pr-stale: -1
+          days-before-pr-close: -1
+          days-before-issue-stale: 1
+          days-before-issue-close: 1
+          remove-stale-when-updated: true
+          stale-issue-label: "stale"
+          exempt-issue-labels: "not-stale"
+          stale-issue-message: >
+            https://github.com/esphome/esphome/issues/430

.gitignore

@@ -13,6 +13,9 @@ __pycache__/
 # Intellij Idea
 .idea
 
+# Vim
+*.swp
+
 # Hide some OS X stuff
 .DS_Store
 .AppleDouble
@@ -74,6 +77,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+venv-*/
 
 # mypy
 .mypy_cache/
@@ -81,7 +85,8 @@ venv.bak/
 .pioenvs
 .piolibdeps
 .pio
-.vscode
+.vscode/
+!.vscode/tasks.json
 CMakeListsPrivate.txt
 CMakeLists.txt
 
@@ -98,8 +103,7 @@ CMakeLists.txt
 .idea/**/dynamic.xml
 
 # CMake
-cmake-build-debug/
-cmake-build-release/
+cmake-build-*/
 
 CMakeCache.txt
 CMakeFiles
@@ -119,3 +123,8 @@ config/
 tests/build/
 tests/.esphome/
 /.temp-clang-tidy.cpp
+/.temp/
+.pio/
+
+sdkconfig.*
+!sdkconfig.defaults

.gitpod.yml

@@ -3,4 +3,4 @@ ports:
   onOpen: open-preview
 tasks:
 - before: pyenv local $(pyenv version | grep '^3\.' | cut -d ' ' -f 1) && script/setup
-  command: python -m esphome config dashboard
+  command: python -m esphome dashboard config

.pre-commit-config.yaml

@@ -1,11 +1,32 @@
 # 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: 22.3.0
     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: 4.0.1
+    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
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v2.31.1
+    hooks:
+      - id: pyupgrade
+        args: [--py38-plus]

.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,57 +13,231 @@ esphome/core/* @esphome/core
 # Integrations
 esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
+esphome/components/addressable_light/* @justfalter
+esphome/components/airthings_ble/* @jeromelaban
+esphome/components/airthings_wave_mini/* @ncareau
+esphome/components/airthings_wave_plus/* @jeromelaban
+esphome/components/am43/* @buxtronix
+esphome/components/am43/cover/* @buxtronix
+esphome/components/analog_threshold/* @ianchi
+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/bedjet/* @jhansche
+esphome/components/bh1750/* @OttoWinter
 esphome/components/binary_sensor/* @esphome/core
+esphome/components/bl0939/* @ziceva
+esphome/components/bl0940/* @tobias-
+esphome/components/ble_client/* @buxtronix
+esphome/components/bme680_bsec/* @trvrnrth
+esphome/components/bmp3xx/* @martgras
+esphome/components/button/* @esphome/core
+esphome/components/canbus/* @danielschramm @mvturnho
+esphome/components/cap1188/* @MrEditor97
 esphome/components/captive_portal/* @OttoWinter
+esphome/components/ccs811/* @habbie
+esphome/components/cd74hc4067/* @asoehlke
 esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
+esphome/components/color_temperature/* @jesserockz
 esphome/components/coolix/* @glmnet
+esphome/components/copy/* @OttoWinter
 esphome/components/cover/* @esphome/core
+esphome/components/cs5460a/* @balrog-kun
+esphome/components/cse7761/* @berfenger
 esphome/components/ct_clamp/* @jesserockz
+esphome/components/current_based/* @djwmarcx
+esphome/components/daly_bms/* @s1lvi0
+esphome/components/dashboard_import/* @esphome/core
 esphome/components/debug/* @OttoWinter
+esphome/components/delonghi/* @grob6000
 esphome/components/dfplayer/* @glmnet
 esphome/components/dht/* @OttoWinter
+esphome/components/ds1307/* @badbadc0ffee
+esphome/components/dsmr/* @glmnet @zuidwijk
+esphome/components/ektf2232/* @jesserockz
+esphome/components/ens210/* @itn3rd77
+esphome/components/esp32/* @esphome/core
+esphome/components/esp32_ble/* @jesserockz
+esphome/components/esp32_ble_server/* @jesserockz
+esphome/components/esp32_camera_web_server/* @ayufan
+esphome/components/esp32_can/* @Sympatron
+esphome/components/esp32_improv/* @jesserockz
+esphome/components/esp8266/* @esphome/core
 esphome/components/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/graph/* @synco
+esphome/components/growatt_solar/* @leeuwte
+esphome/components/havells_solar/* @sourabhjaiswal
+esphome/components/hbridge/fan/* @WeekendWarrior
+esphome/components/hbridge/light/* @DotNetDann
+esphome/components/heatpumpir/* @rob-deutsch
+esphome/components/hitachi_ac424/* @sourabhjaiswal
 esphome/components/homeassistant/* @OttoWinter
+esphome/components/honeywellabp/* @RubyBailey
+esphome/components/hrxl_maxsonar_wr/* @netmikey
+esphome/components/hydreon_rgxx/* @functionpointer
 esphome/components/i2c/* @esphome/core
+esphome/components/i2s_audio/* @jesserockz
+esphome/components/improv_serial/* @esphome/core
+esphome/components/ina260/* @MrEditor97
+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/kalman_combinator/* @Cat-Ion
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
+esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
+esphome/components/lock/* @esphome/core
 esphome/components/logger/* @esphome/core
+esphome/components/ltr390/* @sjtrny
+esphome/components/max31865/* @DAVe3283
+esphome/components/max44009/* @berfenger
+esphome/components/max7219digit/* @rspaargaren
+esphome/components/max9611/* @mckaymatthew
+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/mcp3204/* @rsumner
+esphome/components/mcp4728/* @berfenger
+esphome/components/mcp47a1/* @jesserockz
+esphome/components/mcp9808/* @k7hpn
+esphome/components/md5/* @esphome/core
+esphome/components/mdns/* @esphome/core
+esphome/components/media_player/* @jesserockz
+esphome/components/midea/* @dudanov
+esphome/components/midea_ir/* @dudanov
+esphome/components/mitsubishi/* @RubyBailey
+esphome/components/mlx90393/* @functionpointer
+esphome/components/modbus_controller/* @martgras
+esphome/components/modbus_controller/binary_sensor/* @martgras
+esphome/components/modbus_controller/number/* @martgras
+esphome/components/modbus_controller/output/* @martgras
+esphome/components/modbus_controller/select/* @martgras @stegm
+esphome/components/modbus_controller/sensor/* @martgras
+esphome/components/modbus_controller/switch/* @martgras
+esphome/components/modbus_controller/text_sensor/* @martgras
+esphome/components/mopeka_ble/* @spbrogan
+esphome/components/mopeka_pro_check/* @spbrogan
+esphome/components/mpu6886/* @fabaff
 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/pm1006/* @habbie
+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/preferences/* @esphome/core
+esphome/components/psram/* @esphome/core
+esphome/components/pulse_meter/* @cstaahl @stevebaxter
+esphome/components/pvvx_mithermometer/* @pasiz
+esphome/components/qmp6988/* @andrewpc
+esphome/components/qr_code/* @wjtje
+esphome/components/radon_eye_ble/* @jeffeb3
+esphome/components/radon_eye_rd200/* @jeffeb3
+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/safe_mode/* @jsuanet @paulmonigatti
+esphome/components/scd4x/* @martgras @sjtrny
 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/sen5x/* @martgras
+esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
-esphome/components/shutdown/* @esphome/core
+esphome/components/sgp40/* @SenexCrenshaw
+esphome/components/sgp4x/* @SenexCrenshaw @martgras
+esphome/components/shelly_dimmer/* @edge90 @rnauber
+esphome/components/sht4x/* @sjtrny
+esphome/components/shutdown/* @esphome/core @jsuanet
 esphome/components/sim800l/* @glmnet
+esphome/components/sm2135/* @BoukeHaarsma23
+esphome/components/sml/* @alengwenus
+esphome/components/socket/* @esphome/core
+esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/spi/* @esphome/core
+esphome/components/sps30/* @martgras
+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/st7920/* @marsjan155
 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/touchscreen/* @jesserockz
+esphome/components/tsl2591/* @wjcarpenter
 esphome/components/tuya/binary_sensor/* @jesserockz
 esphome/components/tuya/climate/* @jesserockz
+esphome/components/tuya/number/* @frankiboy1
+esphome/components/tuya/select/* @bearpawmaxim
 esphome/components/tuya/sensor/* @jesserockz
 esphome/components/tuya/switch/* @jesserockz
+esphome/components/tuya/text_sensor/* @dentra
 esphome/components/uart/* @esphome/core
 esphome/components/ultrasonic/* @OttoWinter
 esphome/components/version/* @esphome/core
+esphome/components/wake_on_lan/* @willwill2will54
 esphome/components/web_server_base/* @OttoWinter
 esphome/components/whirlpool/* @glmnet
+esphome/components/xiaomi_lywsd03mmc/* @ahpohl
+esphome/components/xiaomi_mhoc303/* @drug123
+esphome/components/xiaomi_mhoc401/* @vevsvevs
+esphome/components/xiaomi_rtcgq02lm/* @jesserockz
+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.
 

CONTRIBUTING.md

@@ -1,15 +1,11 @@
 # Contributing to ESPHome
 
-This python project is responsible for reading in YAML configuration files,
-converting them to C++ code. This code is then converted to a platformio project and compiled
-with [esphome-core](https://github.com/esphome/esphome-core), the C++ framework behind the project.
-
-For a detailed guide, please see https://esphome.io/guides/contributing.html#contributing-to-esphomeyaml
+For a detailed guide, please see https://esphome.io/guides/contributing.html#contributing-to-esphome
 
 Things to note when contributing:
 
  - Please test your changes :)
- - If a new feature is added or an existing user-facing feature is changed, you should also 
+ - If a new feature is added or an existing user-facing feature is changed, you should also
    update the [docs](https://github.com/esphome/esphome-docs). See [contributing to esphome-docs](https://esphome.io/guides/contributing.html#contributing-to-esphomedocs)
    for more information.
  - Please also update the tests in the `tests/` folder. You can do so by just adding a line in one of the YAML files

MANIFEST.in

@@ -1,6 +1,8 @@
 include LICENSE
 include README.md
+include requirements.txt
 include esphome/dashboard/templates/*.html
 recursive-include esphome/dashboard/static *.ico *.js *.css *.woff* LICENSE
 recursive-include esphome *.cpp *.h *.tcc
+recursive-include esphome *.py.script
 recursive-include esphome LICENSE.txt

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,21 +1,151 @@
-ARG BUILD_FROM=esphome/esphome-base-amd64:2.3.4
-FROM ${BUILD_FROM}
+# Build these with the build.py script
+# Example:
+#   python3 docker/build.py --tag dev --arch amd64 --build-type docker build
+
+# One of "docker", "hassio"
+ARG BASEIMGTYPE=docker
+
+# https://github.com/hassio-addons/addon-debian-base/releases
+FROM ghcr.io/hassio-addons/debian-base/amd64:5.3.0 AS base-hassio-amd64
+FROM ghcr.io/hassio-addons/debian-base/aarch64:5.3.0 AS base-hassio-arm64
+FROM ghcr.io/hassio-addons/debian-base/armv7:5.3.0 AS base-hassio-armv7
+# https://hub.docker.com/_/debian?tab=tags&page=1&name=bullseye
+FROM debian:bullseye-20220328-slim AS base-docker-amd64
+FROM debian:bullseye-20220328-slim AS base-docker-arm64
+FROM debian:bullseye-20220328-slim AS base-docker-armv7
+
+# Use TARGETARCH/TARGETVARIANT defined by docker
+# https://docs.docker.com/engine/reference/builder/#automatic-platform-args-in-the-global-scope
+FROM base-${BASEIMGTYPE}-${TARGETARCH}${TARGETVARIANT} AS base
+
+RUN \
+    apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        python3=3.9.2-3 \
+        python3-pip=20.3.4-4+deb11u1 \
+        python3-setuptools=52.0.0-4 \
+        python3-pil=8.1.2+dfsg-0.3+deb11u1 \
+        python3-cryptography=3.3.2-1 \
+        iputils-ping=3:20210202-1 \
+        git=1:2.30.2-1 \
+        curl=7.74.0-1.3+deb11u1 \
+        openssh-client=1:8.4p1-5 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+ENV \
+  # Fix click python3 lang warning https://click.palletsprojects.com/en/7.x/python3/
+  LANG=C.UTF-8 LC_ALL=C.UTF-8 \
+  # Store globally installed pio libs in /piolibs
+  PLATFORMIO_GLOBALLIB_DIR=/piolibs
+
+RUN \
+    # Ubuntu python3-pip is missing wheel
+    pip3 install --no-cache-dir \
+        wheel==0.37.1 \
+        platformio==5.2.5 \
+    # Change some platformio settings
+    && platformio settings set enable_telemetry No \
+    && platformio settings set check_libraries_interval 1000000 \
+    && platformio settings set check_platformio_interval 1000000 \
+    && platformio settings set check_platforms_interval 1000000 \
+    && mkdir -p /piolibs
+
 
 # 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 . .
-RUN pip3 install --no-cache-dir -e .
+
+# ======================= docker-type image =======================
+FROM base AS docker
+
+# Copy esphome and install
+COPY . /esphome
+RUN pip3 install --no-cache-dir --no-use-pep517 -e /esphome
 
 # Settings for dashboard
 ENV USERNAME="" PASSWORD=""
 
+# Expose the dashboard to Docker
+EXPOSE 6052
+
+COPY docker/docker_entrypoint.sh /entrypoint.sh
+
 # The directory the user should mount their configuration files to
+VOLUME /config
 WORKDIR /config
-# Set entrypoint to esphome so that the user doesn't have to type 'esphome'
+# Set entrypoint to esphome (via a script) so that the user doesn't have to type 'esphome'
 # in every docker command twice
-ENTRYPOINT ["esphome"]
+ENTRYPOINT ["/entrypoint.sh"]
 # When no arguments given, start the dashboard in the workdir
-CMD ["/config", "dashboard"]
+CMD ["dashboard", "/config"]
+
+
+
+
+# ======================= hassio-type image =======================
+FROM base AS hassio
+
+RUN \
+    apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        nginx-light=1.18.0-6.1 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+ARG BUILD_VERSION=dev
+
+# Copy root filesystem
+COPY docker/ha-addon-rootfs/ /
+
+# Copy esphome and install
+COPY . /esphome
+RUN pip3 install --no-cache-dir --no-use-pep517 -e /esphome
+
+# Labels
+LABEL \
+    io.hass.name="ESPHome" \
+    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
+    io.hass.type="addon" \
+    io.hass.version="${BUILD_VERSION}"
+    # io.hass.arch is inherited from addon-debian-base
+
+
+
+
+# ======================= lint-type image =======================
+FROM base AS lint
+
+ENV \
+  PLATFORMIO_CORE_DIR=/esphome/.temp/platformio
+
+RUN \
+    apt-get update \
+    # Use pinned versions so that we get updates with build caching
+    && apt-get install -y --no-install-recommends \
+        clang-format-11=1:11.0.1-2 \
+        clang-tidy-11=1:11.0.1-2 \
+        patch=2.7.6-7 \
+        software-properties-common=0.96.20.2-2.1 \
+        nano=5.4-2 \
+        build-essential=12.9 \
+        python3-dev=3.9.2-3 \
+    && rm -rf \
+        /tmp/* \
+        /var/{cache,log}/* \
+        /var/lib/apt/lists/*
+
+COPY requirements_test.txt /
+RUN pip3 install --no-cache-dir -r /requirements_test.txt
+
+VOLUME ["/esphome"]
+WORKDIR /esphome

docker/Dockerfile.dev

@@ -1,13 +0,0 @@
-FROM esphome/esphome-base-amd64:2.3.4
-
-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

docker/Dockerfile.hassio

@@ -1,23 +0,0 @@
-ARG BUILD_FROM
-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 root filesystem
-COPY docker/rootfs/ /
-
-# Then copy esphome and install
-COPY . /opt/esphome/
-RUN pip3 install --no-cache-dir -e /opt/esphome
-
-# Build arguments
-ARG BUILD_VERSION=dev
-
-# Labels
-LABEL \
-    io.hass.name="ESPHome" \
-    io.hass.description="Manage and program ESP8266/ESP32 microcontrollers through YAML configuration files" \
-    io.hass.type="addon" \
-    io.hass.version=${BUILD_VERSION}

docker/Dockerfile.lint

@@ -1,7 +0,0 @@
-FROM esphome/esphome-lint-base:2.3.4
-
-COPY requirements.txt requirements_test.txt /
-RUN pip3 install --no-cache-dir -r /requirements.txt -r /requirements_test.txt
-
-VOLUME ["/esphome"]
-WORKDIR /esphome

docker/build.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+from dataclasses import dataclass
+import subprocess
+import argparse
+from platform import machine
+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]
+
+
+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")
+build_parser.add_argument("--push", help="Also push the images", action="store_true")
+build_parser.add_argument("--load", help="Load the docker image locally", action="store_true")
+manifest_parser = subparsers.add_parser("manifest", help="Create a manifest from already pushed images")
+
+
+@dataclass(frozen=True)
+class DockerParams:
+    build_to: str
+    manifest_to: str
+    baseimgtype: str
+    platform: str
+    target: 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_to = f"{prefix}-{arch}"
+        baseimgtype = {
+            TYPE_DOCKER: "docker",
+            TYPE_HA_ADDON: "hassio",
+            TYPE_LINT: "docker",
+        }[build_type]
+        platform = {
+            ARCH_AMD64: "linux/amd64",
+            ARCH_ARMV7: "linux/arm/v7",
+            ARCH_AARCH64: "linux/arm64",
+        }[arch]
+        target = {
+            TYPE_DOCKER: "docker",
+            TYPE_HA_ADDON: "hassio",
+            TYPE_LINT: "lint",
+        }[build_type]
+        return cls(
+            build_to=build_to,
+            manifest_to=prefix,
+            baseimgtype=baseimgtype,
+            platform=platform,
+            target=target,
+        )
+
+
+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: "cache-dev",
+            CHANNEL_BETA: "cache-beta",
+            CHANNEL_RELEASE: "cache-latest",
+        }[channel]
+        cache_img = f"ghcr.io/{params.build_to}:{cache_tag}"
+
+        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]
+
+        # 3. build
+        cmd = [
+            "docker", "buildx", "build",
+            "--build-arg", f"BASEIMGTYPE={params.baseimgtype}",
+            "--build-arg", f"BUILD_VERSION={args.tag}",
+            "--cache-from", f"type=registry,ref={cache_img}",
+            "--file", "docker/Dockerfile",
+            "--platform", params.platform,
+            "--target", params.target,
+        ]
+        for img in imgs:
+            cmd += ["--tag", img]
+        if args.push:
+            cmd += ["--push", "--cache-to", f"type=registry,ref={cache_img},mode=max"]
+        if args.load:
+            cmd += ["--load"]
+
+        run_command(*cmd, ".")
+    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/docker_entrypoint.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# If /cache is mounted, use that as PIO's coredir
+# otherwise use path in /config (so that PIO packages aren't downloaded on each compile)
+
+if [[ -d /cache ]]; then
+    pio_cache_base=/cache/platformio
+else
+    pio_cache_base=/config/.esphome/platformio
+fi
+
+if [[ ! -d "${pio_cache_base}" ]]; then
+    echo "Creating cache directory ${pio_cache_base}"
+    echo "You can change this behavior by mounting a directory to the container's /cache directory."
+    mkdir -p "${pio_cache_base}"
+fi
+
+# we can't set core_dir, because the settings file is stored in `core_dir/appstate.json`
+# setting `core_dir` would therefore prevent pio from accessing
+export PLATFORMIO_PLATFORMS_DIR="${pio_cache_base}/platforms"
+export PLATFORMIO_PACKAGES_DIR="${pio_cache_base}/packages"
+export PLATFORMIO_CACHE_DIR="${pio_cache_base}/cache"
+
+exec esphome "$@"

docker/ha-addon-rootfs/etc/cont-init.d/10-requirements.sh

@@ -7,12 +7,12 @@
 # Check SSL requirements, if enabled
 if bashio::config.true 'ssl'; then
     if ! bashio::config.has_value 'certfile'; then
-        bashio::fatal 'SSL is enabled, but no certfile was specified.'
+        bashio::log.fatal 'SSL is enabled, but no certfile was specified.'
         bashio::exit.nok
     fi
 
     if ! bashio::config.has_value 'keyfile'; then
-        bashio::fatal 'SSL is enabled, but no keyfile was specified'
+        bashio::log.fatal 'SSL is enabled, but no keyfile was specified'
         bashio::exit.nok
     fi
 

docker/ha-addon-rootfs/etc/cont-init.d/30-dirs.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# Community Hass.io Add-ons: ESPHome
+# This files creates all directories used by esphome
+# ==============================================================================
+
+pio_cache_base=/data/cache/platformio
+
+mkdir -p "${pio_cache_base}"

docker/ha-addon-rootfs/etc/nginx/servers/direct-ssl.disabled

@@ -10,7 +10,7 @@ server {
     ssl_certificate_key /ssl/%%keyfile%%;
 
     # Clear Hass.io Ingress header
-    proxy_set_header X-Hassio-Ingress "";
+    proxy_set_header X-HA-Ingress "";
 
     # Redirect http requests to https on the same port.
     # https://rageagainstshell.com/2016/11/redirect-http-to-https-on-the-same-port-in-nginx/

docker/ha-addon-rootfs/etc/nginx/servers/direct.disabled

@@ -4,7 +4,7 @@ server {
     include /etc/nginx/includes/server_params.conf;
     include /etc/nginx/includes/proxy_params.conf;
     # Clear Hass.io Ingress header
-    proxy_set_header X-Hassio-Ingress "";
+    proxy_set_header X-HA-Ingress "";
 
     location / {
         proxy_pass http://esphome;

docker/ha-addon-rootfs/etc/nginx/servers/ingress.conf

@@ -3,8 +3,8 @@ server {
 
     include /etc/nginx/includes/server_params.conf;
     include /etc/nginx/includes/proxy_params.conf;
-    # Set Hass.io Ingress header
-    proxy_set_header X-Hassio-Ingress "YES";
+    # Set Home Assistant Ingress header
+    proxy_set_header X-HA-Ingress "YES";
 
     location / {
         # Only allow from Hass.io supervisor

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

@@ -4,7 +4,7 @@
 # Runs the ESPHome dashboard
 # ==============================================================================
 
-export ESPHOME_IS_HASSIO=true
+export ESPHOME_IS_HA_ADDON=true
 
 if bashio::config.true 'leave_front_door_open'; then
     export DISABLE_HA_AUTHENTICATION=true
@@ -22,5 +22,14 @@ if bashio::config.has_value 'relative_url'; then
     export ESPHOME_DASHBOARD_RELATIVE_URL=$(bashio::config 'relative_url')
 fi
 
+pio_cache_base=/data/cache/platformio
+# we can't set core_dir, because the settings file is stored in `core_dir/appstate.json`
+# setting `core_dir` would therefore prevent pio from accessing
+export PLATFORMIO_PLATFORMS_DIR="${pio_cache_base}/platforms"
+export PLATFORMIO_PACKAGES_DIR="${pio_cache_base}/packages"
+export PLATFORMIO_CACHE_DIR="${pio_cache_base}/cache"
+
+export PLATFORMIO_GLOBALLIB_DIR=/piolibs
+
 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 --ha-addon

docker/platformio_install_deps.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# This script is used in the docker containers to preinstall
+# all platformio libraries in the global storage
+
+import configparser
+import subprocess
+import sys
+
+config = configparser.ConfigParser(inline_comment_prefixes=(';', ))
+config.read(sys.argv[1])
+
+libs = []
+# Extract from every lib_deps key in all sections
+for section in config.sections():
+    conf = config[section]
+    if "lib_deps" not in conf:
+        continue
+    for lib_dep in conf["lib_deps"].splitlines():
+        if not lib_dep:
+            # Empty line or comment
+            continue
+        if lib_dep.startswith("${"):
+            # Extending from another section
+            continue
+        if "@" not in lib_dep:
+            # No version pinned, this is an internal lib
+            continue
+        libs.append(lib_dep)
+
+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

esphome/__main__.py

@@ -2,27 +2,49 @@ import argparse
 import functools
 import logging
 import os
+import re
 import sys
 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 (
+    ALLOWED_NAME_CHARS,
+    CONF_BAUD_RATE,
+    CONF_BROKER,
+    CONF_DEASSERT_RTS_DTR,
+    CONF_LOGGER,
+    CONF_NAME,
+    CONF_OTA,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_ESPHOME,
+    CONF_PLATFORMIO_OPTIONS,
+    CONF_SUBSTITUTIONS,
+    SECRETS_FILES,
+)
+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 +54,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 +64,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 +72,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((f"MQTT ({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 +88,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 +102,60 @@ 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("//", "")
+            # remove tailing \ to avoid multi-line comment warning
+            conf_str = conf_str.replace("\\\n", "\n")
             cg.add(cg.LineComment(indent(conf_str)))
-        yield coro(conf)
+        await coro(conf)
 
+    if hasattr(coro, "priority"):
+        wrapped.priority = coro.priority
     return wrapped
 
 
@@ -146,20 +187,60 @@ def compile_program(args, config):
     from esphome import platformio_api
 
     _LOGGER.info("Compiling app...")
-    return platformio_api.run_compile(config, CORE.verbose)
+    rc = platformio_api.run_compile(config, CORE.verbose)
+    if rc != 0:
+        return rc
+    idedata = platformio_api.get_idedata(config)
+    return 0 if idedata is not None else 1
 
 
 def upload_using_esptool(config, port):
-    path = CORE.firmware_bin
-    first_baudrate = config[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS].get('upload_speed', 460800)
+    from esphome import platformio_api
+
+    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]
+        idedata = platformio_api.get_idedata(config)
 
-        if os.environ.get('ESPHOME_USE_SUBPROCESS') is None:
+        firmware_offset = "0x10000" if CORE.is_esp32 else "0x0"
+        flash_images = [
+            platformio_api.FlashImage(
+                path=idedata.firmware_bin_path, offset=firmware_offset
+            ),
+            *idedata.extra_flash_images,
+        ]
+
+        mcu = "esp8266"
+        if CORE.is_esp32:
+            from esphome.components.esp32 import get_esp32_variant
+
+            mcu = get_esp32_variant().lower()
+
+        cmd = [
+            "esptool.py",
+            "--before",
+            "default_reset",
+            "--after",
+            "hard_reset",
+            "--baud",
+            str(baud_rate),
+            "--port",
+            port,
+            "--chip",
+            mcu,
+            "write_flash",
+            "-z",
+            "--flash_size",
+            "detect",
+        ]
+        for img in flash_images:
+            cmd += [img.offset, img.path]
+
+        if os.environ.get("ESPHOME_USE_SUBPROCESS") is None:
             import esptool
+
             # pylint: disable=protected-access
             return run_external_command(esptool._main, *cmd)
 
@@ -169,46 +250,48 @@ 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':
-        from esphome import platformio_api
-
-        if CORE.is_esp8266:
-            return upload_using_esptool(config, host)
-        return platformio_api.run_upload(config, CORE.verbose, host)
+    if get_port_type(host) == "SERIAL":
+        return upload_using_esptool(config, 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]
-    password = ota_conf[CONF_PASSWORD]
+    password = ota_conf.get(CONF_PASSWORD, "")
     return espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
 
 
 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:
-        from esphome.api.client import run_logs
+    if get_port_type(port) == "NETWORK" and "api" in config:
+        from esphome.components.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 +299,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 +321,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 +341,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 +356,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 +374,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 +432,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,169 +442,473 @@ 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(f"Updating {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(f"[{color(Fore.BOLD_GREEN, 'SUCCESS')}] {f}")
             success[f] = True
         else:
-            print_bar("[{}] {}".format(color('bold_red', 'ERROR'), f))
+            print_bar(f"[{color(Fore.BOLD_RED, 'ERROR')}] {f}")
             success[f] = False
 
         print()
         print()
         print()
 
-    print_bar('[{}]'.format(color('bold_white', 'SUMMARY')))
+    print_bar(f"[{color(Fore.BOLD_WHITE, 'SUMMARY')}]")
     failed = 0
     for f in files:
         if success[f]:
-            print("  - {}: {}".format(f, color('green', 'SUCCESS')))
+            print(f"  - {f}: {color(Fore.GREEN, 'SUCCESS')}")
         else:
-            print("  - {}: {}".format(f, color('bold_red', 'FAILED')))
+            print(f"  - {f}: {color(Fore.BOLD_RED, 'FAILED')}")
             failed += 1
     return failed
 
 
+def command_idedata(args, config):
+    from esphome import platformio_api
+    import json
+
+    logging.disable(logging.INFO)
+    logging.disable(logging.WARNING)
+
+    idedata = platformio_api.get_idedata(config)
+    if idedata is None:
+        return 1
+
+    print(json.dumps(idedata.raw, indent=2) + "\n")
+    return 0
+
+
+def command_rename(args, config):
+    for c in args.name:
+        if c not in ALLOWED_NAME_CHARS:
+            print(
+                color(
+                    Fore.BOLD_RED,
+                    f"'{c}' is an invalid character for names. Valid characters are: "
+                    f"{ALLOWED_NAME_CHARS} (lowercase, no spaces)",
+                )
+            )
+            return 1
+    # Load existing yaml file
+    with open(CORE.config_path, mode="r+", encoding="utf-8") as raw_file:
+        raw_contents = raw_file.read()
+
+    yaml = yaml_util.load_yaml(CORE.config_path)
+    if CONF_ESPHOME not in yaml or CONF_NAME not in yaml[CONF_ESPHOME]:
+        print(
+            color(Fore.BOLD_RED, "Complex YAML files cannot be automatically renamed.")
+        )
+        return 1
+    old_name = yaml[CONF_ESPHOME][CONF_NAME]
+    match = re.match(r"^\$\{?([a-zA-Z0-9_]+)\}?$", old_name)
+    if match is None:
+        new_raw = re.sub(
+            rf"name:\s+[\"']?{old_name}[\"']?",
+            f'name: "{args.name}"',
+            raw_contents,
+        )
+    else:
+        old_name = yaml[CONF_SUBSTITUTIONS][match.group(1)]
+        if (
+            len(
+                re.findall(
+                    rf"^\s+{match.group(1)}:\s+[\"']?{old_name}[\"']?",
+                    raw_contents,
+                    flags=re.MULTILINE,
+                )
+            )
+            > 1
+        ):
+            print(color(Fore.BOLD_RED, "Too many matches in YAML to safely rename"))
+            return 1
+
+        new_raw = re.sub(
+            rf"^(\s+{match.group(1)}):\s+[\"']?{old_name}[\"']?",
+            f'\\1: "{args.name}"',
+            raw_contents,
+            flags=re.MULTILINE,
+        )
+
+    new_path = os.path.join(CORE.config_dir, args.name + ".yaml")
+    print(
+        f"Updating {color(Fore.CYAN, CORE.config_path)} to {color(Fore.CYAN, new_path)}"
+    )
+    print()
+
+    with open(new_path, mode="w", encoding="utf-8") as new_file:
+        new_file.write(new_raw)
+
+    rc = run_external_process("esphome", "config", new_path)
+    if rc != 0:
+        print(color(Fore.BOLD_RED, "Rename failed. Reverting changes."))
+        os.remove(new_path)
+        return 1
+
+    cli_args = [
+        "run",
+        new_path,
+        "--no-logs",
+        "--device",
+        CORE.address,
+    ]
+
+    if args.dashboard:
+        cli_args.insert(0, "--dashboard")
+
+    try:
+        rc = run_external_process("esphome", *cli_args)
+    except KeyboardInterrupt:
+        rc = 1
+    if rc != 0:
+        os.remove(new_path)
+        return 1
+
+    os.remove(CORE.config_path)
+
+    print(color(Fore.BOLD_GREEN, "SUCCESS"))
+    print()
+    return 0
+
+
 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,
+    "idedata": command_idedata,
+    "rename": command_rename,
 }
 
 
 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')
+    parser = argparse.ArgumentParser(
+        description=f"ESPHome v{const.__version__}", parents=[options_parser]
+    )
+
+    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(
+        "--address",
+        help="The address to bind to.",
+        type=str,
+        default="0.0.0.0",
+    )
+    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(
+        "--ha-addon", 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")
 
-    return parser.parse_args(argv[1:])
+    parser_update = subparsers.add_parser("update-all")
+    parser_update.add_argument(
+        "configuration", help="Your YAML configuration file directories.", nargs="+"
+    )
+
+    parser_idedata = subparsers.add_parser("idedata")
+    parser_idedata.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs=1
+    )
+
+    parser_rename = subparsers.add_parser(
+        "rename",
+        help="Rename a device in YAML, compile the binary and upload it.",
+    )
+    parser_rename.add_argument(
+        "configuration", help="Your YAML configuration file.", nargs=1
+    )
+    parser_rename.add_argument("name", help="The new name for the device.", type=str)
+
+    # 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, if parsing using the current format fails, construct an ad-hoc parser
+    # 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 retry with the normal parser (and raise
+    # a deprecation warning).
+    arguments = argv[1:]
+
+    # On Python 3.9+ we can simply set exit_on_error=False in the constructor
+    def _raise(x):
+        raise argparse.ArgumentError(None, x)
+
+    # First, try new-style parsing, but don't exit in case of failure
+    try:
+        # duplicate parser so that we can use the original one to raise errors later on
+        current_parser = argparse.ArgumentParser(add_help=False, parents=[parser])
+        current_parser.set_defaults(deprecated_argv_suggestion=None)
+        current_parser.error = _raise
+        return current_parser.parse_args(arguments)
+    except argparse.ArgumentError:
+        pass
+
+    # Second, try compat parsing and rearrange the command-line if it succeeds
+    # 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", action="store_true")
+    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",
+        ],
+    )
+
+    try:
+        compat_parser.error = _raise
+        result, unparsed = compat_parser.parse_known_args(argv[1:])
+        last_option = len(arguments) - len(unparsed) - 1 - len(result.configuration)
+        unparsed = [
+            "--device" if arg in ("--upload-port", "--serial-port") else arg
+            for arg in unparsed
+        ]
+        arguments = (
+            arguments[0:last_option]
+            + [result.command]
+            + result.configuration
+            + unparsed
+        )
+        deprecated_argv_suggestion = arguments
+    except argparse.ArgumentError:
+        # old-style parsing failed, don't suggest any argument
+        deprecated_argv_suggestion = None
+
+    # Finally, run the new-style parser again with the possibly swapped arguments,
+    # and let it error out if the command is unparsable.
+    parser.set_defaults(deprecated_argv_suggestion=deprecated_argv_suggestion)
+    return parser.parse_args(arguments)
 
 
 def run_esphome(argv):
     args = parse_args(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
+    setup_log(
+        args.verbose,
+        args.quiet,
+        # Show timestamp for dashboard access logs
+        args.command == "dashboard",
+    )
+    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))
 
-    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, 8, 0):
+        _LOGGER.error(
+            "You're running ESPHome with Python <3.8. ESPHome is no longer compatible "
+            "with this Python version. Please reinstall ESPHome with Python 3.8+"
+        )
         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:
+        if any(os.path.basename(conf_path) == x for x in SECRETS_FILES):
+            _LOGGER.warning("Skipping secrets file %s", conf_path)
+            continue
+
         CORE.config_path = conf_path
         CORE.dashboard = args.dashboard
 
         config = read_config(dict(args.substitution) if args.substitution else {})
         if config is None:
-            return 1
+            return 2
         CORE.config = config
 
         if args.command not in POST_CONFIG_ACTIONS:
@@ -540,7 +917,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

@@ -1,490 +0,0 @@
-from datetime import datetime
-import functools
-import logging
-import socket
-import threading
-import time
-
-# pylint: disable=unused-import
-from typing import Optional  # noqa
-from google.protobuf import message  # noqa
-
-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.util import safe_print
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class APIConnectionError(EsphomeError):
-    pass
-
-
-MESSAGE_TYPE_TO_PROTO = {
-    1: pb.HelloRequest,
-    2: pb.HelloResponse,
-    3: pb.ConnectRequest,
-    4: pb.ConnectResponse,
-    5: pb.DisconnectRequest,
-    6: pb.DisconnectResponse,
-    7: pb.PingRequest,
-    8: pb.PingResponse,
-    9: pb.DeviceInfoRequest,
-    10: pb.DeviceInfoResponse,
-    11: pb.ListEntitiesRequest,
-    12: pb.ListEntitiesBinarySensorResponse,
-    13: pb.ListEntitiesCoverResponse,
-    14: pb.ListEntitiesFanResponse,
-    15: pb.ListEntitiesLightResponse,
-    16: pb.ListEntitiesSensorResponse,
-    17: pb.ListEntitiesSwitchResponse,
-    18: pb.ListEntitiesTextSensorResponse,
-    19: pb.ListEntitiesDoneResponse,
-    20: pb.SubscribeStatesRequest,
-    21: pb.BinarySensorStateResponse,
-    22: pb.CoverStateResponse,
-    23: pb.FanStateResponse,
-    24: pb.LightStateResponse,
-    25: pb.SensorStateResponse,
-    26: pb.SwitchStateResponse,
-    27: pb.TextSensorStateResponse,
-    28: pb.SubscribeLogsRequest,
-    29: pb.SubscribeLogsResponse,
-    30: pb.CoverCommandRequest,
-    31: pb.FanCommandRequest,
-    32: pb.LightCommandRequest,
-    33: pb.SwitchCommandRequest,
-    34: pb.SubscribeServiceCallsRequest,
-    35: pb.ServiceCallResponse,
-    36: pb.GetTimeRequest,
-    37: pb.GetTimeResponse,
-}
-
-
-def _varuint_to_bytes(value):
-    if value <= 0x7F:
-        return bytes([value])
-
-    ret = bytes()
-    while value:
-        temp = value & 0x7F
-        value >>= 7
-        if value:
-            ret += bytes([temp | 0x80])
-        else:
-            ret += bytes([temp])
-
-    return ret
-
-
-def _bytes_to_varuint(value):
-    result = 0
-    bitpos = 0
-    for val in value:
-        result |= (val & 0x7F) << bitpos
-        bitpos += 7
-        if (val & 0x80) == 0:
-            return result
-    return None
-
-
-# pylint: disable=too-many-instance-attributes,not-callable
-class APIClient(threading.Thread):
-    def __init__(self, address, port, password):
-        threading.Thread.__init__(self)
-        self._address = address  # type: str
-        self._port = port  # type: int
-        self._password = password  # type: Optional[str]
-        self._socket = None  # type: Optional[socket.socket]
-        self._socket_open_event = threading.Event()
-        self._socket_write_lock = threading.Lock()
-        self._connected = False
-        self._authenticated = False
-        self._message_handlers = []
-        self._keepalive = 5
-        self._ping_timer = None
-
-        self.on_disconnect = None
-        self.on_connect = None
-        self.on_login = None
-        self.auto_reconnect = False
-        self._running_event = threading.Event()
-        self._stop_event = threading.Event()
-
-    @property
-    def stopped(self):
-        return self._stop_event.is_set()
-
-    def _refresh_ping(self):
-        if self._ping_timer is not None:
-            self._ping_timer.cancel()
-            self._ping_timer = None
-
-        def func():
-            self._ping_timer = None
-
-            if self._connected:
-                try:
-                    self.ping()
-                except APIConnectionError as err:
-                    self._fatal_error(err)
-                else:
-                    self._refresh_ping()
-
-        self._ping_timer = threading.Timer(self._keepalive, func)
-        self._ping_timer.start()
-
-    def _cancel_ping(self):
-        if self._ping_timer is not None:
-            self._ping_timer.cancel()
-            self._ping_timer = None
-
-    def _close_socket(self):
-        self._cancel_ping()
-        if self._socket is not None:
-            self._socket.close()
-            self._socket = None
-        self._socket_open_event.clear()
-        self._connected = False
-        self._authenticated = False
-        self._message_handlers = []
-
-    def stop(self, force=False):
-        if self.stopped:
-            raise ValueError
-
-        if self._connected and not force:
-            try:
-                self.disconnect()
-            except APIConnectionError:
-                pass
-        self._close_socket()
-
-        self._stop_event.set()
-        if not force:
-            self.join()
-
-    def connect(self):
-        if not self._running_event.wait(0.1):
-            raise APIConnectionError("You need to call start() first!")
-
-        if self._connected:
-            self.disconnect(on_disconnect=False)
-
-        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.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
-        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._socket.settimeout(10.0)
-        self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-        try:
-            self._socket.connect((ip, self._port))
-        except OSError as err:
-            err = APIConnectionError(f"Error connecting to {ip}: {err}")
-            self._fatal_error(err)
-            raise err
-        self._socket.settimeout(0.1)
-
-        self._socket_open_event.set()
-
-        hello = pb.HelloRequest()
-        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)
-        self._connected = True
-        self._refresh_ping()
-        if self.on_connect is not None:
-            self.on_connect()
-
-    def _check_connected(self):
-        if not self._connected:
-            err = APIConnectionError("Must be connected!")
-            self._fatal_error(err)
-            raise err
-
-    def login(self):
-        self._check_connected()
-        if self._authenticated:
-            raise APIConnectionError("Already logged in!")
-
-        connect = pb.ConnectRequest()
-        if self._password is not None:
-            connect.password = self._password
-        resp = self._send_message_await_response(connect, pb.ConnectResponse)
-        if resp.invalid_password:
-            raise APIConnectionError("Invalid password!")
-
-        self._authenticated = True
-        if self.on_login is not None:
-            self.on_login()
-
-    def _fatal_error(self, err):
-        was_connected = self._connected
-
-        self._close_socket()
-
-        if was_connected and self.on_disconnect is not None:
-            self.on_disconnect(err)
-
-    def _write(self, data):  # type: (bytes) -> None
-        if self._socket is None:
-            raise APIConnectionError("Socket closed")
-
-        # _LOGGER.debug("Write: %s", format_bytes(data))
-        with self._socket_write_lock:
-            try:
-                self._socket.sendall(data)
-            except OSError as err:
-                err = APIConnectionError(f"Error while writing data: {err}")
-                self._fatal_error(err)
-                raise err
-
-    def _send_message(self, msg):
-        # type: (message.Message) -> None
-        for message_type, klass in MESSAGE_TYPE_TO_PROTO.items():
-            if isinstance(msg, klass):
-                break
-        else:
-            raise ValueError
-
-        encoded = msg.SerializeToString()
-        _LOGGER.debug("Sending %s:\n%s", type(msg), indent(str(msg)))
-        req = bytes([0])
-        req += _varuint_to_bytes(len(encoded))
-        req += _varuint_to_bytes(message_type)
-        req += encoded
-        self._write(req)
-
-    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=5):
-        event = threading.Event()
-        responses = []
-
-        def on_message(resp):
-            if do_append(resp):
-                responses.append(resp)
-            if do_stop(resp):
-                event.set()
-
-        self._message_handlers.append(on_message)
-        self._send_message(send_msg)
-        ret = event.wait(timeout)
-        try:
-            self._message_handlers.remove(on_message)
-        except ValueError:
-            pass
-        if not ret:
-            raise APIConnectionError("Timeout while waiting for message response!")
-        return responses
-
-    def _send_message_await_response(self, send_msg, response_type, timeout=5):
-        def is_response(msg):
-            return isinstance(msg, response_type)
-
-        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)
-
-    def ping(self):
-        self._check_connected()
-        return self._send_message_await_response(pb.PingRequest(), pb.PingResponse)
-
-    def disconnect(self, on_disconnect=True):
-        self._check_connected()
-
-        try:
-            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
-        except APIConnectionError:
-            pass
-        self._close_socket()
-
-        if self.on_disconnect is not None and on_disconnect:
-            self.on_disconnect(None)
-
-    def _check_authenticated(self):
-        if not self._authenticated:
-            raise APIConnectionError("Must login first!")
-
-    def subscribe_logs(self, on_log, log_level=7, dump_config=False):
-        self._check_authenticated()
-
-        def on_msg(msg):
-            if isinstance(msg, pb.SubscribeLogsResponse):
-                on_log(msg)
-
-        self._message_handlers.append(on_msg)
-        req = pb.SubscribeLogsRequest(dump_config=dump_config)
-        req.level = log_level
-        self._send_message(req)
-
-    def _recv(self, amount):
-        ret = bytes()
-        if amount == 0:
-            return ret
-
-        while len(ret) < amount:
-            if self.stopped:
-                raise APIConnectionError("Stopped!")
-            if not self._socket_open_event.is_set():
-                raise APIConnectionError("No socket!")
-            try:
-                val = self._socket.recv(amount - len(ret))
-            except AttributeError:
-                raise APIConnectionError("Socket was closed")
-            except socket.timeout:
-                continue
-            except OSError as err:
-                raise APIConnectionError(f"Error while receiving data: {err}")
-            ret += val
-        return ret
-
-    def _recv_varint(self):
-        raw = bytes()
-        while not raw or raw[-1] & 0x80:
-            raw += self._recv(1)
-        return _bytes_to_varuint(raw)
-
-    def _run_once(self):
-        if not self._socket_open_event.wait(0.1):
-            return
-
-        # Preamble
-        if self._recv(1)[0] != 0x00:
-            raise APIConnectionError("Invalid preamble")
-
-        length = self._recv_varint()
-        msg_type = self._recv_varint()
-
-        raw_msg = self._recv(length)
-        if msg_type not in MESSAGE_TYPE_TO_PROTO:
-            _LOGGER.debug("Skipping message type %s", msg_type)
-            return
-
-        msg = MESSAGE_TYPE_TO_PROTO[msg_type]()
-        msg.ParseFromString(raw_msg)
-        _LOGGER.debug("Got message: %s:\n%s", type(msg), indent(str(msg)))
-        for msg_handler in self._message_handlers[:]:
-            msg_handler(msg)
-        self._handle_internal_messages(msg)
-
-    def run(self):
-        self._running_event.set()
-        while not self.stopped:
-            try:
-                self._run_once()
-            except APIConnectionError as err:
-                if self.stopped:
-                    break
-                if self._connected:
-                    _LOGGER.error("Error while reading incoming messages: %s", err)
-                    self._fatal_error(err)
-        self._running_event.clear()
-
-    def _handle_internal_messages(self, msg):
-        if isinstance(msg, pb.DisconnectRequest):
-            self._send_message(pb.DisconnectResponse())
-            if self._socket is not None:
-                self._socket.close()
-                self._socket = None
-            self._connected = False
-            if self.on_disconnect is not None:
-                self.on_disconnect(None)
-        elif isinstance(msg, pb.PingRequest):
-            self._send_message(pb.PingResponse())
-        elif isinstance(msg, pb.GetTimeRequest):
-            resp = pb.GetTimeResponse()
-            resp.epoch_seconds = int(time.time())
-            self._send_message(resp)
-
-
-def run_logs(config, address):
-    conf = config['api']
-    port = conf[CONF_PORT]
-    password = conf[CONF_PASSWORD]
-    _LOGGER.info("Starting log output from %s using esphome API", address)
-
-    cli = APIClient(address, port, password)
-    stopping = False
-    retry_timer = []
-
-    has_connects = []
-
-    def try_connect(err, tries=0):
-        if stopping:
-            return
-
-        if err:
-            _LOGGER.warning("Disconnected from API: %s", err)
-
-        while retry_timer:
-            retry_timer.pop(0).cancel()
-
-        error = None
-        try:
-            cli.connect()
-            cli.login()
-        except APIConnectionError as err2:  # noqa
-            error = err2
-
-        if error is None:
-            _LOGGER.info("Successfully connected to %s", address)
-            return
-
-        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)
-        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))
-        timer.start()
-        retry_timer.append(timer)
-
-    def on_log(msg):
-        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)')
-        safe_print(time_ + text)
-
-    def on_login():
-        try:
-            cli.subscribe_logs(on_log, dump_config=not has_connects)
-            has_connects.append(True)
-        except APIConnectionError:
-            cli.disconnect()
-
-    cli.on_disconnect = try_connect
-    cli.on_login = on_login
-    cli.start()
-
-    try:
-        try_connect(None)
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        stopping = True
-        cli.stop(True)
-        while retry_timer:
-            retry_timer.pop(0).cancel()
-    return 0

esphome/automation.py

@@ -1,8 +1,18 @@
 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_COUNT,
+    CONF_ELSE,
+    CONF_ID,
+    CONF_THEN,
+    CONF_TIMEOUT,
+    CONF_TRIGGER_ID,
+    CONF_TYPE_ID,
+    CONF_TIME,
+)
+from esphome.jsonschema import jschema_extractor
 from esphome.util import Registry
 
 
@@ -13,7 +23,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 +45,35 @@ 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)
+RepeatAction = cg.esphome_ns.class_("RepeatAction", 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 +97,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 +111,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 +130,218 @@ 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({
+@register_action(
+    "repeat",
+    RepeatAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_COUNT): cv.templatable(cv.positive_not_null_int),
+            cv.Required(CONF_THEN): validate_action_list,
+        }
+    ),
+)
+async def repeat_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    count_template = await cg.templatable(config[CONF_COUNT], args, cg.uint32)
+    cg.add(var.set_count(count_template))
+    actions = await build_action_list(config[CONF_THEN], template_arg, args)
+    cg.add(var.add_then(actions))
+    return var
+
+
+_validate_wait_until = cv.maybe_simple_value(
+    {
         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})
+        cv.Optional(CONF_TIMEOUT): cv.templatable(cv.positive_time_period_milliseconds),
+    },
+    key=CONF_CONDITION,
+)
 
 
-@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
+    if CONF_TIMEOUT in config:
+        template_ = await cg.templatable(config[CONF_TIMEOUT], args, cg.uint32)
+        cg.add(var.set_timeout_value(template_))
+    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/codegen.py

@@ -9,18 +9,79 @@
 
 # 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,
+    add_platformio_option,
+    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,
+    int64,
+    size_t,
+    const_char_ptr,
+    NAN,
+    esphome_ns,
+    App,
+    EntityBase,
+    Component,
+    ComponentPtr,
+    PollingComponent,
+    Application,
+    optional,
+    arduino_json_ns,
+    JsonObject,
+    JsonObjectConst,
+    Controller,
+    GPIOPin,
+    InternalGPIOPin,
+    gpio_Flags,
+    EntityCategory,
+    Parented,
+)

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/esphal.h"
+#include "esphome/core/hal.h"
 #include "esphome/components/stepper/stepper.h"
 
 namespace esphome {
@@ -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

@@ -1,28 +1,37 @@
+#ifdef USE_ARDUINO
+
 #include "ac_dimmer.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include <cmath>
 
-#ifdef ARDUINO_ARCH_ESP8266
+#ifdef USE_ESP8266
 #include <core_esp8266_waveform.h>
 #endif
+#ifdef USE_ESP32_FRAMEWORK_ARDUINO
+#include <esp32-hal-timer.h>
+#endif
 
 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;
+/// However other factors like gate driver propagation time
+/// are also considered and a really low value is not important
+/// See also: https://github.com/esphome/issues/issues/1632
+static const uint32_t GATE_ENABLE_TIME = 50;
 
 /// Function called from timer interrupt
 /// Input is current time in microseconds (micros())
 /// Returns when next "event" is expected in µs, or 0 if no such event known.
-uint32_t ICACHE_RAM_ATTR HOT AcDimmerDataStore::timer_intr(uint32_t now) {
+uint32_t IRAM_ATTR HOT AcDimmerDataStore::timer_intr(uint32_t now) {
   // If no ZC signal received yet.
   if (this->crossed_zero_at == 0)
     return 0;
@@ -34,19 +43,19 @@ uint32_t ICACHE_RAM_ATTR HOT AcDimmerDataStore::timer_intr(uint32_t now) {
 
   if (this->enable_time_us != 0 && time_since_zc >= this->enable_time_us) {
     this->enable_time_us = 0;
-    this->gate_pin->digital_write(true);
+    this->gate_pin.digital_write(true);
     // Prevent too short pulses
-    this->disable_time_us = max(this->disable_time_us, time_since_zc + GATE_ENABLE_TIME);
+    this->disable_time_us = std::max(this->disable_time_us, time_since_zc + GATE_ENABLE_TIME);
   }
   if (this->disable_time_us != 0 && time_since_zc >= this->disable_time_us) {
     this->disable_time_us = 0;
-    this->gate_pin->digital_write(false);
+    this->gate_pin.digital_write(false);
   }
 
-  if (time_since_zc < this->enable_time_us)
+  if (time_since_zc < this->enable_time_us) {
     // Next event is enable, return time until that event
     return this->enable_time_us - time_since_zc;
-  else if (time_since_zc < disable_time_us) {
+  } else if (time_since_zc < disable_time_us) {
     // Next event is disable, return time until that event
     return this->disable_time_us - time_since_zc;
   }
@@ -60,14 +69,15 @@ uint32_t ICACHE_RAM_ATTR HOT AcDimmerDataStore::timer_intr(uint32_t now) {
 }
 
 /// Run timer interrupt code and return in how many µs the next event is expected
-uint32_t ICACHE_RAM_ATTR HOT timer_interrupt() {
+uint32_t IRAM_ATTR HOT timer_interrupt() {
   // run at least with 1kHz
   uint32_t min_dt_us = 1000;
   uint32_t now = micros();
   for (auto *dimmer : all_dimmers) {
-    if (dimmer == nullptr)
+    if (dimmer == nullptr) {
       // no more dimmers
       break;
+    }
     uint32_t res = dimmer->timer_intr(now);
     if (res != 0 && res < min_dt_us)
       min_dt_us = res;
@@ -77,7 +87,7 @@ uint32_t ICACHE_RAM_ATTR HOT timer_interrupt() {
 }
 
 /// GPIO interrupt routine, called when ZC pin triggers
-void ICACHE_RAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
+void IRAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
   uint32_t prev_crossed = this->crossed_zero_at;
 
   // 50Hz mains frequency should give a half cycle of 10ms a 60Hz will give 8.33ms
@@ -94,7 +104,7 @@ void ICACHE_RAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
 
   if (this->value == 65535) {
     // fully on, enable output immediately
-    this->gate_pin->digital_write(true);
+    this->gate_pin.digital_write(true);
   } else if (this->init_cycle) {
     // send a full cycle
     this->init_cycle = false;
@@ -102,30 +112,34 @@ void ICACHE_RAM_ATTR HOT AcDimmerDataStore::gpio_intr() {
     this->disable_time_us = cycle_time_us;
   } else if (this->value == 0) {
     // fully off, disable output immediately
-    this->gate_pin->digital_write(false);
+    this->gate_pin.digital_write(false);
   } else {
     if (this->method == DIM_METHOD_TRAILING) {
       this->enable_time_us = 1;  // cannot be 0
-      this->disable_time_us = max((uint32_t) 10, this->value * this->cycle_time_us / 65535);
+      this->disable_time_us = std::max((uint32_t) 10, this->value * this->cycle_time_us / 65535);
     } else {
       // calculate time until enable in µs: (1.0-value)*cycle_time, but with integer arithmetic
       // also take into account min_power
       auto min_us = this->cycle_time_us * this->min_power / 1000;
-      this->enable_time_us = max((uint32_t) 1, ((65535 - this->value) * (this->cycle_time_us - min_us)) / 65535);
+      // calculate required value to provide a true RMS voltage output
+      this->enable_time_us =
+          std::max((uint32_t) 1, (uint32_t)((65535 - (acos(1 - (2 * this->value / 65535.0)) / 3.14159 * 65535)) *
+                                            (this->cycle_time_us - min_us)) /
+                                     65535);
       if (this->method == DIM_METHOD_LEADING_PULSE) {
         // Minimum pulse time should be enough for the triac to trigger when it is close to the ZC zone
         // this is for brightness near 99%
-        this->disable_time_us = max(this->enable_time_us + GATE_ENABLE_TIME, (uint32_t) cycle_time_us / 10);
+        this->disable_time_us = std::max(this->enable_time_us + GATE_ENABLE_TIME, (uint32_t) cycle_time_us / 10);
       } else {
-        this->gate_pin->digital_write(false);
+        this->gate_pin.digital_write(false);
         this->disable_time_us = this->cycle_time_us;
       }
     }
   }
 }
 
-void ICACHE_RAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store) {
-  // Attaching pin interrupts on the same pin will override the previous interupt
+void IRAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store) {
+  // 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*.
@@ -138,11 +152,11 @@ void ICACHE_RAM_ATTR HOT AcDimmerDataStore::s_gpio_intr(AcDimmerDataStore *store
   }
 }
 
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef USE_ESP32
 // ESP32 implementation, uses basically the same code but needs to wrap
 // timer_interrupt() function to auto-reschedule
-static hw_timer_t *dimmer_timer = nullptr;
-void ICACHE_RAM_ATTR HOT AcDimmerDataStore::s_timer_intr() { timer_interrupt(); }
+static hw_timer_t *dimmer_timer = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+void IRAM_ATTR HOT AcDimmerDataStore::s_timer_intr() { timer_interrupt(); }
 #endif
 
 void AcDimmer::setup() {
@@ -171,15 +185,16 @@ void AcDimmer::setup() {
   if (setup_zero_cross_pin) {
     this->zero_cross_pin_->setup();
     this->store_.zero_cross_pin = this->zero_cross_pin_->to_isr();
-    this->zero_cross_pin_->attach_interrupt(&AcDimmerDataStore::s_gpio_intr, &this->store_, FALLING);
+    this->zero_cross_pin_->attach_interrupt(&AcDimmerDataStore::s_gpio_intr, &this->store_,
+                                            gpio::INTERRUPT_FALLING_EDGE);
   }
 
-#ifdef ARDUINO_ARCH_ESP8266
+#ifdef USE_ESP8266
   // Uses ESP8266 waveform (soft PWM) class
   // PWM and AcDimmer can even run at the same time this way
   setTimer1Callback(&timer_interrupt);
 #endif
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef USE_ESP32
   // 80 Divider -> 1 count=1µs
   dimmer_timer = timerBegin(0, 80, true);
   timerAttachInterrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr, true);
@@ -202,12 +217,13 @@ void AcDimmer::dump_config() {
   LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
   ESP_LOGCONFIG(TAG, "   Min Power: %.1f%%", this->store_.min_power / 10.0f);
   ESP_LOGCONFIG(TAG, "   Init with half cycle: %s", YESNO(this->init_with_half_cycle_));
-  if (method_ == DIM_METHOD_LEADING_PULSE)
+  if (method_ == DIM_METHOD_LEADING_PULSE) {
     ESP_LOGCONFIG(TAG, "   Method: leading pulse");
-  else if (method_ == DIM_METHOD_LEADING)
+  } else if (method_ == DIM_METHOD_LEADING) {
     ESP_LOGCONFIG(TAG, "   Method: leading");
-  else
+  } else {
     ESP_LOGCONFIG(TAG, "   Method: trailing");
+  }
 
   LOG_FLOAT_OUTPUT(this);
   ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
@@ -215,3 +231,5 @@ void AcDimmer::dump_config() {
 
 }  // namespace ac_dimmer
 }  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/ac_dimmer.h

@@ -1,7 +1,9 @@
 #pragma once
 
+#ifdef USE_ARDUINO
+
 #include "esphome/core/component.h"
-#include "esphome/core/esphal.h"
+#include "esphome/core/hal.h"
 #include "esphome/components/output/float_output.h"
 
 namespace esphome {
@@ -11,11 +13,11 @@ enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TR
 
 struct AcDimmerDataStore {
   /// Zero-cross pin
-  ISRInternalGPIOPin *zero_cross_pin;
+  ISRInternalGPIOPin zero_cross_pin;
   /// Zero-cross pin number - used to share ZC pin across multiple dimmers
   uint8_t zero_cross_pin_number;
   /// Output pin to write to
-  ISRInternalGPIOPin *gate_pin;
+  ISRInternalGPIOPin gate_pin;
   /// Value of the dimmer - 0 to 65535.
   uint16_t value;
   /// Minimum power for activation
@@ -37,7 +39,7 @@ struct AcDimmerDataStore {
 
   void gpio_intr();
   static void s_gpio_intr(AcDimmerDataStore *store);
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef USE_ESP32
   static void s_timer_intr();
 #endif
 };
@@ -47,16 +49,16 @@ class AcDimmer : public output::FloatOutput, public Component {
   void setup() override;
 
   void dump_config() override;
-  void set_gate_pin(GPIOPin *gate_pin) { gate_pin_ = gate_pin; }
-  void set_zero_cross_pin(GPIOPin *zero_cross_pin) { zero_cross_pin_ = zero_cross_pin; }
+  void set_gate_pin(InternalGPIOPin *gate_pin) { gate_pin_ = gate_pin; }
+  void set_zero_cross_pin(InternalGPIOPin *zero_cross_pin) { zero_cross_pin_ = zero_cross_pin; }
   void set_init_with_half_cycle(bool init_with_half_cycle) { init_with_half_cycle_ = init_with_half_cycle; }
   void set_method(DimMethod method) { method_ = method; }
 
  protected:
   void write_state(float state) override;
 
-  GPIOPin *gate_pin_;
-  GPIOPin *zero_cross_pin_;
+  InternalGPIOPin *gate_pin_;
+  InternalGPIOPin *zero_cross_pin_;
   AcDimmerDataStore store_;
   bool init_with_half_cycle_;
   DimMethod method_;
@@ -64,3 +66,5 @@ class AcDimmer : public output::FloatOutput, public Component {
 
 }  // namespace ac_dimmer
 }  // namespace esphome
+
+#endif  // USE_ARDUINO

esphome/components/ac_dimmer/output.py

@@ -4,42 +4,49 @@ 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 = cv.All(
+    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),
+    cv.only_with_arduino,
+)
 
 
-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;
@@ -25,7 +25,7 @@ void AdalightLightEffect::stop() {
   AddressableLightEffect::stop();
 }
 
-int AdalightLightEffect::get_frame_size_(int led_count) const {
+unsigned int AdalightLightEffect::get_frame_size_(int led_count) const {
   // 3 bytes: Ada
   // 2 bytes: LED count
   // 1 byte: checksum
@@ -42,11 +42,12 @@ 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);
   }
+  it.schedule_show();
 }
 
-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,9 +131,10 @@ 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));
   }
 
+  it.schedule_show();
   return CONSUMED;
 }
 

esphome/components/adalight/adalight_light_effect.h

@@ -13,10 +13,9 @@ class AdalightLightEffect : public light::AddressableLightEffect, public uart::U
  public:
   AdalightLightEffect(const std::string &name);
 
- 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 {
@@ -25,12 +24,11 @@ class AdalightLightEffect : public light::AddressableLightEffect, public uart::U
     CONSUMED,
   };
 
-  int get_frame_size_(int led_count) const;
+  unsigned int get_frame_size_(int led_count) const;
   void reset_frame_(light::AddressableLight &it);
   void blank_all_leds_(light::AddressableLight &it);
   Frame parse_frame_(light::AddressableLight &it);
 
- protected:
   uint32_t last_ack_{0};
   uint32_t last_byte_{0};
   uint32_t last_reset_{0};

esphome/components/adc/__init__.py

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

esphome/components/adc/adc_sensor.cpp

@@ -1,90 +1,185 @@
 #include "adc_sensor.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
+#ifdef USE_ESP8266
 #ifdef USE_ADC_SENSOR_VCC
+#include <Esp.h>
 ADC_MODE(ADC_VCC)
+#else
+#include <Arduino.h>
+#endif
 #endif
 
 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; }
+// 13bit for S2, and 12bit for all other esp32 variants
+#ifdef USE_ESP32
+static const adc_bits_width_t ADC_WIDTH_MAX_SOC_BITS = static_cast<adc_bits_width_t>(ADC_WIDTH_MAX - 1);
+
+#ifndef SOC_ADC_RTC_MAX_BITWIDTH
+#if USE_ESP32_VARIANT_ESP32S2
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 13;
+#else
+static const int SOC_ADC_RTC_MAX_BITWIDTH = 12;
+#endif
+#endif
+
+static const int ADC_MAX = (1 << SOC_ADC_RTC_MAX_BITWIDTH) - 1;    // 4095 (12 bit) or 8191 (13 bit)
+static const int ADC_HALF = (1 << SOC_ADC_RTC_MAX_BITWIDTH) >> 1;  // 2048 (12 bit) or 4096 (13 bit)
 #endif
 
 void ADCSensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
-  GPIOPin(this->pin_, INPUT).setup();
-
-#ifdef ARDUINO_ARCH_ESP32
-  analogSetPinAttenuation(this->pin_, this->attenuation_);
+#ifndef USE_ADC_SENSOR_VCC
+  pin_->setup();
 #endif
+
+#ifdef USE_ESP32
+  adc1_config_width(ADC_WIDTH_MAX_SOC_BITS);
+  if (!autorange_) {
+    adc1_config_channel_atten(channel_, attenuation_);
+  }
+
+  // load characteristics for each attenuation
+  for (int i = 0; i < (int) ADC_ATTEN_MAX; i++) {
+    auto cal_value = esp_adc_cal_characterize(ADC_UNIT_1, (adc_atten_t) i, ADC_WIDTH_MAX_SOC_BITS,
+                                              1100,  // default vref
+                                              &cal_characteristics_[i]);
+    switch (cal_value) {
+      case ESP_ADC_CAL_VAL_EFUSE_VREF:
+        ESP_LOGV(TAG, "Using eFuse Vref for calibration");
+        break;
+      case ESP_ADC_CAL_VAL_EFUSE_TP:
+        ESP_LOGV(TAG, "Using two-point eFuse Vref for calibration");
+        break;
+      case ESP_ADC_CAL_VAL_DEFAULT_VREF:
+      default:
+        break;
+    }
+  }
+
+  // adc_gpio_init doesn't exist on ESP32-S2, ESP32-C3 or ESP32-H2
+#if !defined(USE_ESP32_VARIANT_ESP32C3) && !defined(USE_ESP32_VARIANT_ESP32H2) && !defined(USE_ESP32_VARIANT_ESP32S2)
+  adc_gpio_init(ADC_UNIT_1, (adc_channel_t) channel_);
+#endif
+#endif  // USE_ESP32
 }
+
 void ADCSensor::dump_config() {
   LOG_SENSOR("", "ADC Sensor", this);
-#ifdef ARDUINO_ARCH_ESP8266
+#ifdef USE_ESP8266
 #ifdef USE_ADC_SENSOR_VCC
   ESP_LOGCONFIG(TAG, "  Pin: VCC");
 #else
-  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
+  LOG_PIN("  Pin: ", pin_);
 #endif
-#endif
-#ifdef ARDUINO_ARCH_ESP32
-  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
-  switch (this->attenuation_) {
-    case ADC_0db:
-      ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
-      break;
-    case ADC_2_5db:
-      ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
-      break;
-    case ADC_6db:
-      ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
-      break;
-    case ADC_11db:
-      ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
-      break;
+#endif  // USE_ESP8266
+
+#ifdef USE_ESP32
+  LOG_PIN("  Pin: ", pin_);
+  if (autorange_) {
+    ESP_LOGCONFIG(TAG, " Attenuation: auto");
+  } else {
+    switch (this->attenuation_) {
+      case ADC_ATTEN_DB_0:
+        ESP_LOGCONFIG(TAG, " Attenuation: 0db");
+        break;
+      case ADC_ATTEN_DB_2_5:
+        ESP_LOGCONFIG(TAG, " Attenuation: 2.5db");
+        break;
+      case ADC_ATTEN_DB_6:
+        ESP_LOGCONFIG(TAG, " Attenuation: 6db");
+        break;
+      case ADC_ATTEN_DB_11:
+        ESP_LOGCONFIG(TAG, " Attenuation: 11db");
+        break;
+      default:  // This is to satisfy the unused ADC_ATTEN_MAX
+        break;
+    }
   }
-#endif
+#endif  // USE_ESP32
   LOG_UPDATE_INTERVAL(this);
 }
+
 float ADCSensor::get_setup_priority() const { return setup_priority::DATA; }
 void ADCSensor::update() {
   float value_v = this->sample();
-  ESP_LOGD(TAG, "'%s': Got voltage=%.2fV", this->get_name().c_str(), value_v);
+  ESP_LOGV(TAG, "'%s': Got voltage=%.4fV", this->get_name().c_str(), value_v);
   this->publish_state(value_v);
 }
+
+#ifdef USE_ESP8266
 float ADCSensor::sample() {
-#ifdef ARDUINO_ARCH_ESP32
-  float value_v = analogRead(this->pin_) / 4095.0f;  // NOLINT
-  switch (this->attenuation_) {
-    case ADC_0db:
-      value_v *= 1.1;
-      break;
-    case ADC_2_5db:
-      value_v *= 1.5;
-      break;
-    case ADC_6db:
-      value_v *= 2.2;
-      break;
-    case ADC_11db:
-      value_v *= 3.9;
-      break;
+#ifdef USE_ADC_SENSOR_VCC
+  int raw = ESP.getVcc();  // NOLINT(readability-static-accessed-through-instance)
+#else
+  int raw = analogRead(this->pin_->get_pin());  // NOLINT
+#endif
+  if (output_raw_) {
+    return raw;
   }
-  return value_v;
+  return raw / 1024.0f;
+}
 #endif
 
-#ifdef ARDUINO_ARCH_ESP8266
-#ifdef USE_ADC_SENSOR_VCC
-  return ESP.getVcc() / 1024.0f;
-#else
-  return analogRead(this->pin_) / 1024.0f;  // NOLINT
-#endif
-#endif
+#ifdef USE_ESP32
+float ADCSensor::sample() {
+  if (!autorange_) {
+    int raw = adc1_get_raw(channel_);
+    if (raw == -1) {
+      return NAN;
+    }
+    if (output_raw_) {
+      return raw;
+    }
+    uint32_t mv = esp_adc_cal_raw_to_voltage(raw, &cal_characteristics_[(int) attenuation_]);
+    return mv / 1000.0f;
+  }
+
+  int raw11, raw6 = ADC_MAX, raw2 = ADC_MAX, raw0 = ADC_MAX;
+  adc1_config_channel_atten(channel_, ADC_ATTEN_DB_11);
+  raw11 = adc1_get_raw(channel_);
+  if (raw11 < ADC_MAX) {
+    adc1_config_channel_atten(channel_, ADC_ATTEN_DB_6);
+    raw6 = adc1_get_raw(channel_);
+    if (raw6 < ADC_MAX) {
+      adc1_config_channel_atten(channel_, ADC_ATTEN_DB_2_5);
+      raw2 = adc1_get_raw(channel_);
+      if (raw2 < ADC_MAX) {
+        adc1_config_channel_atten(channel_, ADC_ATTEN_DB_0);
+        raw0 = adc1_get_raw(channel_);
+      }
+    }
+  }
+
+  if (raw0 == -1 || raw2 == -1 || raw6 == -1 || raw11 == -1) {
+    return NAN;
+  }
+
+  uint32_t mv11 = esp_adc_cal_raw_to_voltage(raw11, &cal_characteristics_[(int) ADC_ATTEN_DB_11]);
+  uint32_t mv6 = esp_adc_cal_raw_to_voltage(raw6, &cal_characteristics_[(int) ADC_ATTEN_DB_6]);
+  uint32_t mv2 = esp_adc_cal_raw_to_voltage(raw2, &cal_characteristics_[(int) ADC_ATTEN_DB_2_5]);
+  uint32_t mv0 = esp_adc_cal_raw_to_voltage(raw0, &cal_characteristics_[(int) ADC_ATTEN_DB_0]);
+
+  // Contribution of each value, in range 0-2048 (12 bit ADC) or 0-4096 (13 bit ADC)
+  uint32_t c11 = std::min(raw11, ADC_HALF);
+  uint32_t c6 = ADC_HALF - std::abs(raw6 - ADC_HALF);
+  uint32_t c2 = ADC_HALF - std::abs(raw2 - ADC_HALF);
+  uint32_t c0 = std::min(ADC_MAX - raw0, ADC_HALF);
+  // max theoretical csum value is 4096*4 = 16384
+  uint32_t csum = c11 + c6 + c2 + c0;
+
+  // each mv is max 3900; so max value is 3900*4096*4, fits in unsigned32
+  uint32_t mv_scaled = (mv11 * c11) + (mv6 * c6) + (mv2 * c2) + (mv0 * c0);
+  return mv_scaled / (float) (csum * 1000U);
 }
-#ifdef ARDUINO_ARCH_ESP8266
+#endif  // USE_ESP32
+
+#ifdef USE_ESP8266
 std::string ADCSensor::unique_id() { return get_mac_address() + "-adc"; }
 #endif
 

esphome/components/adc/adc_sensor.h

@@ -1,19 +1,26 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/esphal.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/defines.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/voltage_sampler/voltage_sampler.h"
 
+#ifdef USE_ESP32
+#include "driver/adc.h"
+#include <esp_adc_cal.h>
+#endif
+
 namespace esphome {
 namespace adc {
 
 class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage_sampler::VoltageSampler {
  public:
-#ifdef ARDUINO_ARCH_ESP32
+#ifdef USE_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) { attenuation_ = attenuation; }
+  void set_channel(adc1_channel_t channel) { channel_ = channel; }
+  void set_autorange(bool autorange) { autorange_ = autorange; }
 #endif
 
   /// Update adc values.
@@ -23,18 +30,23 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   void dump_config() override;
   /// `HARDWARE_LATE` setup priority.
   float get_setup_priority() const override;
-  void set_pin(uint8_t pin) { this->pin_ = pin; }
+  void set_pin(InternalGPIOPin *pin) { this->pin_ = pin; }
+  void set_output_raw(bool output_raw) { output_raw_ = output_raw; }
   float sample() override;
 
-#ifdef ARDUINO_ARCH_ESP8266
+#ifdef USE_ESP8266
   std::string unique_id() override;
 #endif
 
  protected:
-  uint8_t pin_;
+  InternalGPIOPin *pin_;
+  bool output_raw_{false};
 
-#ifdef ARDUINO_ARCH_ESP32
-  adc_attenuation_t attenuation_{ADC_0db};
+#ifdef USE_ESP32
+  adc_atten_t attenuation_{ADC_ATTEN_DB_0};
+  adc1_channel_t channel_{};
+  bool autorange_{false};
+  esp_adc_cal_characteristics_t cal_characteristics_[(int) ADC_ATTEN_MAX] = {};
 #endif
 };
 

esphome/components/adc/sensor.py

@@ -2,47 +2,179 @@ 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_RAW,
+    CONF_ID,
+    CONF_INPUT,
+    CONF_NUMBER,
+    CONF_PIN,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+)
+from esphome.core import CORE
+from esphome.components.esp32 import get_esp32_variant
+from esphome.components.esp32.const import (
+    VARIANT_ESP32,
+    VARIANT_ESP32C3,
+    VARIANT_ESP32H2,
+    VARIANT_ESP32S2,
+    VARIANT_ESP32S3,
+)
 
 
-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,
+    "auto": "auto",
+}
+
+adc1_channel_t = cg.global_ns.enum("adc1_channel_t")
+
+# From https://github.com/espressif/esp-idf/blob/master/components/driver/include/driver/adc_common.h
+# pin to adc1 channel mapping
+ESP32_VARIANT_ADC1_PIN_TO_CHANNEL = {
+    VARIANT_ESP32: {
+        36: adc1_channel_t.ADC1_CHANNEL_0,
+        37: adc1_channel_t.ADC1_CHANNEL_1,
+        38: adc1_channel_t.ADC1_CHANNEL_2,
+        39: adc1_channel_t.ADC1_CHANNEL_3,
+        32: adc1_channel_t.ADC1_CHANNEL_4,
+        33: adc1_channel_t.ADC1_CHANNEL_5,
+        34: adc1_channel_t.ADC1_CHANNEL_6,
+        35: adc1_channel_t.ADC1_CHANNEL_7,
+    },
+    VARIANT_ESP32S2: {
+        1: adc1_channel_t.ADC1_CHANNEL_0,
+        2: adc1_channel_t.ADC1_CHANNEL_1,
+        3: adc1_channel_t.ADC1_CHANNEL_2,
+        4: adc1_channel_t.ADC1_CHANNEL_3,
+        5: adc1_channel_t.ADC1_CHANNEL_4,
+        6: adc1_channel_t.ADC1_CHANNEL_5,
+        7: adc1_channel_t.ADC1_CHANNEL_6,
+        8: adc1_channel_t.ADC1_CHANNEL_7,
+        9: adc1_channel_t.ADC1_CHANNEL_8,
+        10: adc1_channel_t.ADC1_CHANNEL_9,
+    },
+    VARIANT_ESP32S3: {
+        1: adc1_channel_t.ADC1_CHANNEL_0,
+        2: adc1_channel_t.ADC1_CHANNEL_1,
+        3: adc1_channel_t.ADC1_CHANNEL_2,
+        4: adc1_channel_t.ADC1_CHANNEL_3,
+        5: adc1_channel_t.ADC1_CHANNEL_4,
+        6: adc1_channel_t.ADC1_CHANNEL_5,
+        7: adc1_channel_t.ADC1_CHANNEL_6,
+        8: adc1_channel_t.ADC1_CHANNEL_7,
+        9: adc1_channel_t.ADC1_CHANNEL_8,
+        10: adc1_channel_t.ADC1_CHANNEL_9,
+    },
+    VARIANT_ESP32C3: {
+        0: adc1_channel_t.ADC1_CHANNEL_0,
+        1: adc1_channel_t.ADC1_CHANNEL_1,
+        2: adc1_channel_t.ADC1_CHANNEL_2,
+        3: adc1_channel_t.ADC1_CHANNEL_3,
+        4: adc1_channel_t.ADC1_CHANNEL_4,
+    },
+    VARIANT_ESP32H2: {
+        0: adc1_channel_t.ADC1_CHANNEL_0,
+        1: adc1_channel_t.ADC1_CHANNEL_1,
+        2: adc1_channel_t.ADC1_CHANNEL_2,
+        3: adc1_channel_t.ADC1_CHANNEL_3,
+        4: adc1_channel_t.ADC1_CHANNEL_4,
+    },
 }
 
 
 def validate_adc_pin(value):
-    vcc = str(value).upper()
-    if vcc == 'VCC':
-        return cv.only_on_esp8266(vcc)
-    return pins.analog_pin(value)
+    if str(value).upper() == "VCC":
+        return cv.only_on_esp8266("VCC")
+
+    if CORE.is_esp32:
+        value = pins.internal_gpio_input_pin_number(value)
+        variant = get_esp32_variant()
+        if variant not in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL:
+            raise cv.Invalid(f"This ESP32 variant ({variant}) is not supported")
+
+        if value not in ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant]:
+            raise cv.Invalid(f"{variant} doesn't support ADC on this pin")
+        return pins.internal_gpio_input_pin_schema(value)
+
+    if CORE.is_esp8266:
+        from esphome.components.esp8266.gpio import CONF_ANALOG
+
+        value = pins.internal_gpio_pin_number({CONF_ANALOG: True, CONF_INPUT: True})(
+            value
+        )
+
+        if value != 17:  # A0
+            raise cv.Invalid("ESP8266: Only pin A0 (GPIO17) supports ADC.")
+        return pins.gpio_pin_schema(
+            {CONF_ANALOG: True, CONF_INPUT: True}, internal=True
+        )(value)
+
+    raise NotImplementedError
 
 
-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'))
+def validate_config(config):
+    if config[CONF_RAW] and config.get(CONF_ATTENUATION, None) == "auto":
+        raise cv.Invalid("Automatic attenuation cannot be used when raw output is set.")
+    return config
 
 
-def to_code(config):
+adc_ns = cg.esphome_ns.namespace("adc")
+ADCSensor = adc_ns.class_(
+    "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)
+
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        ADCSensor,
+        unit_of_measurement=UNIT_VOLT,
+        accuracy_decimals=2,
+        device_class=DEVICE_CLASS_VOLTAGE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.Required(CONF_PIN): validate_adc_pin,
+            cv.Optional(CONF_RAW, default=False): cv.boolean,
+            cv.SplitDefault(CONF_ATTENUATION, esp32="0db"): cv.All(
+                cv.only_on_esp32, cv.enum(ATTENUATION_MODES, lower=True)
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s")),
+    validate_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]))
+        pin = await cg.gpio_pin_expression(config[CONF_PIN])
+        cg.add(var.set_pin(pin))
+
+    if CONF_RAW in config:
+        cg.add(var.set_output_raw(config[CONF_RAW]))
 
     if CONF_ATTENUATION in config:
-        cg.add(var.set_attenuation(config[CONF_ATTENUATION]))
+        if config[CONF_ATTENUATION] == "auto":
+            cg.add(var.set_autorange(cg.global_ns.true))
+        else:
+            cg.add(var.set_attenuation(config[CONF_ATTENUATION]))
+
+    if CORE.is_esp32:
+        variant = get_esp32_variant()
+        pin_num = config[CONF_PIN][CONF_NUMBER]
+        chan = ESP32_VARIANT_ADC1_PIN_TO_CHANNEL[variant][pin_num]
+        cg.add(var.set_channel(chan))

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,61 @@
+#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();
+
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+
+ 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,11 @@
 namespace esphome {
 namespace ade7953 {
 
-static const char *TAG = "ade7953";
+static const char *const TAG = "ade7953";
 
 void ADE7953::dump_config() {
   ESP_LOGCONFIG(TAG, "ADE7953:");
+  LOG_PIN("  IRQ Pin: ", irq_pin_);
   LOG_I2C_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Voltage Sensor", this->voltage_sensor_);
@@ -17,27 +18,28 @@ void ADE7953::dump_config() {
   LOG_SENSOR("  ", "Active Power B Sensor", this->active_power_b_sensor_);
 }
 
-#define ADE_PUBLISH_(name, factor) \
-  if (name && this->name##_sensor_) { \
-    float value = *name / factor; \
+#define ADE_PUBLISH_(name, val, factor) \
+  if (err == i2c::ERROR_OK && this->name##_sensor_) { \
+    float value = (val) / (factor); \
     this->name##_sensor_->publish_state(value); \
   }
-#define ADE_PUBLISH(name, factor) ADE_PUBLISH_(name, factor)
+#define ADE_PUBLISH(name, val, factor) ADE_PUBLISH_(name, val, factor)
 
 void ADE7953::update() {
   if (!this->is_setup_)
     return;
 
-  auto active_power_a = this->ade_read_<int32_t>(0x0312);
-  ADE_PUBLISH(active_power_a, 154.0f);
-  auto active_power_b = this->ade_read_<int32_t>(0x0313);
-  ADE_PUBLISH(active_power_b, 154.0f);
-  auto current_a = this->ade_read_<uint32_t>(0x031A);
-  ADE_PUBLISH(current_a, 100000.0f);
-  auto current_b = this->ade_read_<uint32_t>(0x031B);
-  ADE_PUBLISH(current_b, 100000.0f);
-  auto voltage = this->ade_read_<uint32_t>(0x031C);
-  ADE_PUBLISH(voltage, 26000.0f);
+  uint32_t val;
+  i2c::ErrorCode err = ade_read_32_(0x0312, &val);
+  ADE_PUBLISH(active_power_a, (int32_t) val, 154.0f);
+  err = ade_read_32_(0x0313, &val);
+  ADE_PUBLISH(active_power_b, (int32_t) val, 154.0f);
+  err = ade_read_32_(0x031A, &val);
+  ADE_PUBLISH(current_a, (uint32_t) val, 100000.0f);
+  err = ade_read_32_(0x031B, &val);
+  ADE_PUBLISH(current_b, (uint32_t) val, 100000.0f);
+  err = ade_read_32_(0x031C, &val);
+  ADE_PUBLISH(voltage, (uint32_t) val, 26000.0f);
 
   //    auto apparent_power_a = this->ade_read_<int32_t>(0x0310);
   //    auto apparent_power_b = this->ade_read_<int32_t>(0x0311);

esphome/components/ade7953/ade7953.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/hal.h"
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/sensor/sensor.h"
 
@@ -9,6 +10,7 @@ namespace ade7953 {
 
 class ADE7953 : public i2c::I2CDevice, public PollingComponent {
  public:
+  void set_irq_pin(InternalGPIOPin *irq_pin) { irq_pin_ = 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,10 +22,13 @@ class ADE7953 : public i2c::I2CDevice, public PollingComponent {
   }
 
   void setup() override {
+    if (this->irq_pin_ != nullptr) {
+      this->irq_pin_->setup();
+    }
     this->set_timeout(100, [this]() {
-      this->ade_write_<uint8_t>(0x0010, 0x04);
-      this->ade_write_<uint8_t>(0x00FE, 0xAD);
-      this->ade_write_<uint16_t>(0x0120, 0x0030);
+      this->ade_write_8_(0x0010, 0x04);
+      this->ade_write_8_(0x00FE, 0xAD);
+      this->ade_write_16_(0x0120, 0x0030);
       this->is_setup_ = true;
     });
   }
@@ -33,28 +38,51 @@ class ADE7953 : public i2c::I2CDevice, public PollingComponent {
   void update() override;
 
  protected:
-  template<typename T> bool ade_write_(uint16_t reg, T value) {
+  i2c::ErrorCode ade_write_8_(uint16_t reg, uint8_t value) {
     std::vector<uint8_t> data;
     data.push_back(reg >> 8);
     data.push_back(reg >> 0);
-    for (int i = sizeof(T) - 1; i >= 0; i--)
-      data.push_back(value >> (i * 8));
-    return this->write_bytes_raw(data);
+    data.push_back(value);
+    return write(data.data(), data.size());
   }
-  template<typename T> optional<T> ade_read_(uint16_t reg) {
-    uint8_t hi = reg >> 8;
-    uint8_t lo = reg >> 0;
-    if (!this->write_bytes_raw({hi, lo}))
-      return {};
-    auto ret = this->read_bytes_raw<sizeof(T)>();
-    if (!ret.has_value())
-      return {};
-    T result = 0;
-    for (int i = 0, j = sizeof(T) - 1; i < sizeof(T); i++, j--)
-      result |= T((*ret)[i]) << (j * 8);
-    return result;
+  i2c::ErrorCode ade_write_16_(uint16_t reg, uint16_t value) {
+    std::vector<uint8_t> data;
+    data.push_back(reg >> 8);
+    data.push_back(reg >> 0);
+    data.push_back(value >> 8);
+    data.push_back(value >> 0);
+    return write(data.data(), data.size());
+  }
+  i2c::ErrorCode ade_write_32_(uint16_t reg, uint32_t value) {
+    std::vector<uint8_t> data;
+    data.push_back(reg >> 8);
+    data.push_back(reg >> 0);
+    data.push_back(value >> 24);
+    data.push_back(value >> 16);
+    data.push_back(value >> 8);
+    data.push_back(value >> 0);
+    return write(data.data(), data.size());
+  }
+  i2c::ErrorCode ade_read_32_(uint16_t reg, uint32_t *value) {
+    uint8_t reg_data[2];
+    reg_data[0] = reg >> 8;
+    reg_data[1] = reg >> 0;
+    i2c::ErrorCode err = write(reg_data, 2);
+    if (err != i2c::ERROR_OK)
+      return err;
+    uint8_t recv[4];
+    err = read(recv, 4);
+    if (err != i2c::ERROR_OK)
+      return err;
+    *value = 0;
+    *value |= ((uint32_t) recv[0]) << 24;
+    *value |= ((uint32_t) recv[1]) << 16;
+    *value |= ((uint32_t) recv[2]) << 8;
+    *value |= ((uint32_t) recv[3]);
+    return i2c::ERROR_OK;
   }
 
+  InternalGPIOPin *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,90 @@
 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.internal_gpio_input_pin_schema,
+            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:
+        irq_pin = await cg.gpio_pin_expression(config[CONF_IRQ_PIN])
+        cg.add(var.set_irq_pin(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

@@ -1,10 +1,11 @@
 #include "ads1115.h"
 #include "esphome/core/log.h"
+#include "esphome/core/hal.h"
 
 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 +65,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 +103,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();
     }
   }
 
@@ -159,7 +160,7 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
 float ADS1115Sensor::sample() { return this->parent_->request_measurement(this); }
 void ADS1115Sensor::update() {
   float v = this->parent_->request_measurement(this);
-  if (!isnan(v)) {
+  if (!std::isnan(v)) {
     ESP_LOGD(TAG, "'%s': Got Voltage=%fV", this->get_name().c_str(), v);
     this->publish_state(v);
   }

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(
+        ADS1115Sensor,
+        unit_of_measurement=UNIT_VOLT,
+        accuracy_decimals=3,
+        device_class=DEVICE_CLASS_VOLTAGE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            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,20 +10,21 @@
 //
 // 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"
+#include "esphome/core/hal.h"
 
 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...");
@@ -33,8 +34,19 @@ void AHT10Component::setup() {
     this->mark_failed();
     return;
   }
-  uint8_t data;
-  if (!this->read_byte(0, &data, AHT10_DEFAULT_DELAY)) {
+  uint8_t data = 0;
+  if (this->write(&data, 1) != i2c::ERROR_OK) {
+    ESP_LOGD(TAG, "Communication with AHT10 failed!");
+    this->mark_failed();
+    return;
+  }
+  delay(AHT10_DEFAULT_DELAY);
+  if (this->read(&data, 1) != i2c::ERROR_OK) {
+    ESP_LOGD(TAG, "Communication with AHT10 failed!");
+    this->mark_failed();
+    return;
+  }
+  if (this->read(&data, 1) != i2c::ERROR_OK) {
     ESP_LOGD(TAG, "Communication with AHT10 failed!");
     this->mark_failed();
     return;
@@ -55,14 +67,19 @@ void AHT10Component::update() {
     return;
   }
   uint8_t data[6];
-  uint8_t delay = AHT10_DEFAULT_DELAY;
+  uint8_t delay_ms = 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());
-    if (!this->read_bytes(0, data, 6, delay)) {
+    delay_ms = AHT10_HUMIDITY_DELAY;
+  bool success = false;
+  for (int i = 0; i < AHT10_ATTEMPTS; ++i) {
+    ESP_LOGVV(TAG, "Attempt %d at %6u", i, millis());
+    delay(delay_ms);
+    if (this->read(data, 6) != i2c::ERROR_OK) {
       ESP_LOGD(TAG, "Communication with AHT10 failed, waiting...");
-    } else if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy
+      continue;
+    }
+
+    if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy
       ESP_LOGD(TAG, "AHT10 is busy, waiting...");
     } else if (data[1] == 0x0 && data[2] == 0x0 && (data[3] >> 4) == 0x0) {
       // Unrealistic humidity (0x0)
@@ -79,11 +96,12 @@ void AHT10Component::update() {
       }
     } else {
       // data is valid, we can break the loop
-      ESP_LOGVV(TAG, "Answer at %6ld", millis());
+      ESP_LOGVV(TAG, "Answer at %6u", millis());
+      success = true;
       break;
     }
   }
-  if ((data[0] & 0x80) == 0x80) {
+  if (!success || (data[0] & 0x80) == 0x80) {
     ESP_LOGE(TAG, "Measurements reading timed-out!");
     this->status_set_warning();
     return;
@@ -92,19 +110,19 @@ void AHT10Component::update() {
   uint32_t raw_temperature = ((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5];
   uint32_t raw_humidity = ((data[1] << 16) | (data[2] << 8) | data[3]) >> 4;
 
-  float temperature = ((200.0 * (float) raw_temperature) / 1048576.0) - 50.0;
+  float temperature = ((200.0f * (float) raw_temperature) / 1048576.0f) - 50.0f;
   float humidity;
   if (raw_humidity == 0) {  // unrealistic value
     humidity = NAN;
   } else {
-    humidity = (float) raw_humidity * 100.0 / 1048576.0;
+    humidity = (float) raw_humidity * 100.0f / 1048576.0f;
   }
 
   if (this->temperature_sensor_ != nullptr) {
     this->temperature_sensor_->publish_state(temperature);
   }
   if (this->humidity_sensor_ != nullptr) {
-    if (isnan(humidity))
+    if (std::isnan(humidity))
       ESP_LOGW(TAG, "Invalid humidity! Sensor reported 0%% Hum");
     this->humidity_sensor_->publish_state(humidity);
   }

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/airthings_ble/__init__.py

@@ -0,0 +1,23 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import esp32_ble_tracker
+from esphome.const import CONF_ID
+
+DEPENDENCIES = ["esp32_ble_tracker"]
+CODEOWNERS = ["@jeromelaban"]
+
+airthings_ble_ns = cg.esphome_ns.namespace("airthings_ble")
+AirthingsListener = airthings_ble_ns.class_(
+    "AirthingsListener", esp32_ble_tracker.ESPBTDeviceListener
+)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(AirthingsListener),
+    }
+).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+
+
+def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    yield esp32_ble_tracker.register_ble_device(var, config)

esphome/components/airthings_ble/airthings_listener.cpp

@@ -0,0 +1,33 @@
+#include "airthings_listener.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace airthings_ble {
+
+static const char *const TAG = "airthings_ble";
+
+bool AirthingsListener::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
+  for (auto &it : device.get_manufacturer_datas()) {
+    if (it.uuid == esp32_ble_tracker::ESPBTUUID::from_uint32(0x0334)) {
+      if (it.data.size() < 4)
+        continue;
+
+      uint32_t sn = it.data[0];
+      sn |= ((uint32_t) it.data[1] << 8);
+      sn |= ((uint32_t) it.data[2] << 16);
+      sn |= ((uint32_t) it.data[3] << 24);
+
+      ESP_LOGD(TAG, "Found AirThings device Serial:%u (MAC: %s)", sn, device.address_str().c_str());
+      return true;
+    }
+  }
+
+  return false;
+}
+
+}  // namespace airthings_ble
+}  // namespace esphome
+
+#endif

esphome/components/airthings_ble/airthings_listener.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include "esphome/core/component.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+namespace esphome {
+namespace airthings_ble {
+
+class AirthingsListener : public esp32_ble_tracker::ESPBTDeviceListener {
+ public:
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
+};
+
+}  // namespace airthings_ble
+}  // namespace esphome
+
+#endif

esphome/components/airthings_wave_mini/__init__.py

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

esphome/components/airthings_wave_mini/airthings_wave_mini.cpp

@@ -0,0 +1,113 @@
+#include "airthings_wave_mini.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace airthings_wave_mini {
+
+static const char *const TAG = "airthings_wave_mini";
+
+void AirthingsWaveMini::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, "Connected successfully!");
+      }
+      break;
+    }
+
+    case ESP_GATTC_DISCONNECT_EVT: {
+      ESP_LOGW(TAG, "Disconnected!");
+      break;
+    }
+
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      this->handle_ = 0;
+      auto *chr = this->parent()->get_characteristic(service_uuid_, sensors_data_characteristic_uuid_);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", service_uuid_.to_string().c_str(),
+                 sensors_data_characteristic_uuid_.to_string().c_str());
+        break;
+      }
+      this->handle_ = chr->handle;
+      this->node_state = esp32_ble_tracker::ClientState::ESTABLISHED;
+
+      request_read_values_();
+      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_) {
+        read_sensors_(param->read.value, param->read.value_len);
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
+void AirthingsWaveMini::read_sensors_(uint8_t *raw_value, uint16_t value_len) {
+  auto *value = (WaveMiniReadings *) raw_value;
+
+  if (sizeof(WaveMiniReadings) <= value_len) {
+    this->humidity_sensor_->publish_state(value->humidity / 100.0f);
+    this->pressure_sensor_->publish_state(value->pressure / 50.0f);
+    this->temperature_sensor_->publish_state(value->temperature / 100.0f - 273.15f);
+    if (is_valid_voc_value_(value->voc)) {
+      this->tvoc_sensor_->publish_state(value->voc);
+    }
+
+    // This instance must not stay connected
+    // so other clients can connect to it (e.g. the
+    // mobile app).
+    parent()->set_enabled(false);
+  }
+}
+
+bool AirthingsWaveMini::is_valid_voc_value_(uint16_t voc) { return 0 <= voc && voc <= 16383; }
+
+void AirthingsWaveMini::update() {
+  if (this->node_state != esp32_ble_tracker::ClientState::ESTABLISHED) {
+    if (!parent()->enabled) {
+      ESP_LOGW(TAG, "Reconnecting to device");
+      parent()->set_enabled(true);
+      parent()->connect();
+    } else {
+      ESP_LOGW(TAG, "Connection in progress");
+    }
+  }
+}
+
+void AirthingsWaveMini::request_read_values_() {
+  auto status =
+      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle_, ESP_GATT_AUTH_REQ_NONE);
+  if (status) {
+    ESP_LOGW(TAG, "Error sending read request for sensor, status=%d", status);
+  }
+}
+
+void AirthingsWaveMini::dump_config() {
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
+  LOG_SENSOR("  ", "TVOC", this->tvoc_sensor_);
+}
+
+AirthingsWaveMini::AirthingsWaveMini()
+    : PollingComponent(10000),
+      service_uuid_(esp32_ble_tracker::ESPBTUUID::from_raw(SERVICE_UUID)),
+      sensors_data_characteristic_uuid_(esp32_ble_tracker::ESPBTUUID::from_raw(CHARACTERISTIC_UUID)) {}
+
+}  // namespace airthings_wave_mini
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/airthings_wave_mini/airthings_wave_mini.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <esp_gattc_api.h>
+#include <algorithm>
+#include <iterator>
+#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/core/component.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace airthings_wave_mini {
+
+static const char *const SERVICE_UUID = "b42e3882-ade7-11e4-89d3-123b93f75cba";
+static const char *const CHARACTERISTIC_UUID = "b42e3b98-ade7-11e4-89d3-123b93f75cba";
+
+class AirthingsWaveMini : public PollingComponent, public ble_client::BLEClientNode {
+ public:
+  AirthingsWaveMini();
+
+  void dump_config() 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 set_temperature(sensor::Sensor *temperature) { temperature_sensor_ = temperature; }
+  void set_humidity(sensor::Sensor *humidity) { humidity_sensor_ = humidity; }
+  void set_pressure(sensor::Sensor *pressure) { pressure_sensor_ = pressure; }
+  void set_tvoc(sensor::Sensor *tvoc) { tvoc_sensor_ = tvoc; }
+
+ protected:
+  bool is_valid_voc_value_(uint16_t voc);
+
+  void read_sensors_(uint8_t *value, uint16_t value_len);
+  void request_read_values_();
+
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *humidity_sensor_{nullptr};
+  sensor::Sensor *pressure_sensor_{nullptr};
+  sensor::Sensor *tvoc_sensor_{nullptr};
+
+  uint16_t handle_;
+  esp32_ble_tracker::ESPBTUUID service_uuid_;
+  esp32_ble_tracker::ESPBTUUID sensors_data_characteristic_uuid_;
+
+  struct WaveMiniReadings {
+    uint16_t unused01;
+    uint16_t temperature;
+    uint16_t pressure;
+    uint16_t humidity;
+    uint16_t voc;
+    uint16_t unused02;
+    uint32_t unused03;
+    uint32_t unused04;
+  };
+};
+
+}  // namespace airthings_wave_mini
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/airthings_wave_mini/sensor.py

@@ -0,0 +1,82 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, ble_client
+
+from esphome.const import (
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PERCENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    CONF_ID,
+    CONF_HUMIDITY,
+    CONF_TVOC,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    UNIT_PARTS_PER_BILLION,
+    ICON_RADIATOR,
+)
+
+DEPENDENCIES = ["ble_client"]
+
+airthings_wave_mini_ns = cg.esphome_ns.namespace("airthings_wave_mini")
+AirthingsWaveMini = airthings_wave_mini_ns.class_(
+    "AirthingsWaveMini", cg.PollingComponent, ble_client.BLEClientNode
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AirthingsWaveMini),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+                accuracy_decimals=2,
+            ),
+            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_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=2,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_TVOC): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_BILLION,
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("5min"))
+    .extend(ble_client.BLE_CLIENT_SCHEMA),
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    await ble_client.register_ble_node(var, config)
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+    if CONF_PRESSURE in config:
+        sens = await sensor.new_sensor(config[CONF_PRESSURE])
+        cg.add(var.set_pressure(sens))
+    if CONF_TVOC in config:
+        sens = await sensor.new_sensor(config[CONF_TVOC])
+        cg.add(var.set_tvoc(sens))

esphome/components/airthings_wave_plus/__init__.py

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

esphome/components/airthings_wave_plus/airthings_wave_plus.cpp

@@ -0,0 +1,137 @@
+#include "airthings_wave_plus.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace airthings_wave_plus {
+
+static const char *const TAG = "airthings_wave_plus";
+
+void AirthingsWavePlus::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, "Connected successfully!");
+      }
+      break;
+    }
+
+    case ESP_GATTC_DISCONNECT_EVT: {
+      ESP_LOGW(TAG, "Disconnected!");
+      break;
+    }
+
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      this->handle_ = 0;
+      auto *chr = this->parent()->get_characteristic(service_uuid_, sensors_data_characteristic_uuid_);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "No sensor characteristic found at service %s char %s", service_uuid_.to_string().c_str(),
+                 sensors_data_characteristic_uuid_.to_string().c_str());
+        break;
+      }
+      this->handle_ = chr->handle;
+      this->node_state = esp32_ble_tracker::ClientState::ESTABLISHED;
+
+      request_read_values_();
+      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_) {
+        read_sensors_(param->read.value, param->read.value_len);
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
+void AirthingsWavePlus::read_sensors_(uint8_t *raw_value, uint16_t value_len) {
+  auto *value = (WavePlusReadings *) raw_value;
+
+  if (sizeof(WavePlusReadings) <= value_len) {
+    ESP_LOGD(TAG, "version = %d", value->version);
+
+    if (value->version == 1) {
+      ESP_LOGD(TAG, "ambient light = %d", value->ambientLight);
+
+      this->humidity_sensor_->publish_state(value->humidity / 2.0f);
+      if (is_valid_radon_value_(value->radon)) {
+        this->radon_sensor_->publish_state(value->radon);
+      }
+      if (is_valid_radon_value_(value->radon_lt)) {
+        this->radon_long_term_sensor_->publish_state(value->radon_lt);
+      }
+      this->temperature_sensor_->publish_state(value->temperature / 100.0f);
+      this->pressure_sensor_->publish_state(value->pressure / 50.0f);
+      if (is_valid_co2_value_(value->co2)) {
+        this->co2_sensor_->publish_state(value->co2);
+      }
+      if (is_valid_voc_value_(value->voc)) {
+        this->tvoc_sensor_->publish_state(value->voc);
+      }
+
+      // This instance must not stay connected
+      // so other clients can connect to it (e.g. the
+      // mobile app).
+      parent()->set_enabled(false);
+    } else {
+      ESP_LOGE(TAG, "Invalid payload version (%d != 1, newer version or not a Wave Plus?)", value->version);
+    }
+  }
+}
+
+bool AirthingsWavePlus::is_valid_radon_value_(uint16_t radon) { return 0 <= radon && radon <= 16383; }
+
+bool AirthingsWavePlus::is_valid_voc_value_(uint16_t voc) { return 0 <= voc && voc <= 16383; }
+
+bool AirthingsWavePlus::is_valid_co2_value_(uint16_t co2) { return 0 <= co2 && co2 <= 16383; }
+
+void AirthingsWavePlus::update() {
+  if (this->node_state != esp32_ble_tracker::ClientState::ESTABLISHED) {
+    if (!parent()->enabled) {
+      ESP_LOGW(TAG, "Reconnecting to device");
+      parent()->set_enabled(true);
+      parent()->connect();
+    } else {
+      ESP_LOGW(TAG, "Connection in progress");
+    }
+  }
+}
+
+void AirthingsWavePlus::request_read_values_() {
+  auto status =
+      esp_ble_gattc_read_char(this->parent()->gattc_if, this->parent()->conn_id, this->handle_, ESP_GATT_AUTH_REQ_NONE);
+  if (status) {
+    ESP_LOGW(TAG, "Error sending read request for sensor, status=%d", status);
+  }
+}
+
+void AirthingsWavePlus::dump_config() {
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+  LOG_SENSOR("  ", "Radon", this->radon_sensor_);
+  LOG_SENSOR("  ", "Radon Long Term", this->radon_long_term_sensor_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
+  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  LOG_SENSOR("  ", "TVOC", this->tvoc_sensor_);
+}
+
+AirthingsWavePlus::AirthingsWavePlus()
+    : PollingComponent(10000),
+      service_uuid_(esp32_ble_tracker::ESPBTUUID::from_raw(SERVICE_UUID)),
+      sensors_data_characteristic_uuid_(esp32_ble_tracker::ESPBTUUID::from_raw(CHARACTERISTIC_UUID)) {}
+
+}  // namespace airthings_wave_plus
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/airthings_wave_plus/airthings_wave_plus.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <esp_gattc_api.h>
+#include <algorithm>
+#include <iterator>
+#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/core/component.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace airthings_wave_plus {
+
+static const char *const SERVICE_UUID = "b42e1c08-ade7-11e4-89d3-123b93f75cba";
+static const char *const CHARACTERISTIC_UUID = "b42e2a68-ade7-11e4-89d3-123b93f75cba";
+
+class AirthingsWavePlus : public PollingComponent, public ble_client::BLEClientNode {
+ public:
+  AirthingsWavePlus();
+
+  void dump_config() 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 set_temperature(sensor::Sensor *temperature) { temperature_sensor_ = temperature; }
+  void set_radon(sensor::Sensor *radon) { radon_sensor_ = radon; }
+  void set_radon_long_term(sensor::Sensor *radon_long_term) { radon_long_term_sensor_ = radon_long_term; }
+  void set_humidity(sensor::Sensor *humidity) { humidity_sensor_ = humidity; }
+  void set_pressure(sensor::Sensor *pressure) { pressure_sensor_ = pressure; }
+  void set_co2(sensor::Sensor *co2) { co2_sensor_ = co2; }
+  void set_tvoc(sensor::Sensor *tvoc) { tvoc_sensor_ = tvoc; }
+
+ protected:
+  bool is_valid_radon_value_(uint16_t radon);
+  bool is_valid_voc_value_(uint16_t voc);
+  bool is_valid_co2_value_(uint16_t co2);
+
+  void read_sensors_(uint8_t *value, uint16_t value_len);
+  void request_read_values_();
+
+  sensor::Sensor *temperature_sensor_{nullptr};
+  sensor::Sensor *radon_sensor_{nullptr};
+  sensor::Sensor *radon_long_term_sensor_{nullptr};
+  sensor::Sensor *humidity_sensor_{nullptr};
+  sensor::Sensor *pressure_sensor_{nullptr};
+  sensor::Sensor *co2_sensor_{nullptr};
+  sensor::Sensor *tvoc_sensor_{nullptr};
+
+  uint16_t handle_;
+  esp32_ble_tracker::ESPBTUUID service_uuid_;
+  esp32_ble_tracker::ESPBTUUID sensors_data_characteristic_uuid_;
+
+  struct WavePlusReadings {
+    uint8_t version;
+    uint8_t humidity;
+    uint8_t ambientLight;
+    uint8_t unused01;
+    uint16_t radon;
+    uint16_t radon_lt;
+    uint16_t temperature;
+    uint16_t pressure;
+    uint16_t co2;
+    uint16_t voc;
+  };
+};
+
+}  // namespace airthings_wave_plus
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/airthings_wave_plus/sensor.py

@@ -0,0 +1,116 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, ble_client
+
+from esphome.const import (
+    DEVICE_CLASS_CARBON_DIOXIDE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_PRESSURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PERCENT,
+    UNIT_CELSIUS,
+    UNIT_HECTOPASCAL,
+    ICON_RADIOACTIVE,
+    CONF_ID,
+    CONF_RADON,
+    CONF_RADON_LONG_TERM,
+    CONF_HUMIDITY,
+    CONF_TVOC,
+    CONF_CO2,
+    CONF_PRESSURE,
+    CONF_TEMPERATURE,
+    UNIT_BECQUEREL_PER_CUBIC_METER,
+    UNIT_PARTS_PER_MILLION,
+    UNIT_PARTS_PER_BILLION,
+    ICON_RADIATOR,
+)
+
+DEPENDENCIES = ["ble_client"]
+
+airthings_wave_plus_ns = cg.esphome_ns.namespace("airthings_wave_plus")
+AirthingsWavePlus = airthings_wave_plus_ns.class_(
+    "AirthingsWavePlus", cg.PollingComponent, ble_client.BLEClientNode
+)
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(AirthingsWavePlus),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                device_class=DEVICE_CLASS_HUMIDITY,
+                state_class=STATE_CLASS_MEASUREMENT,
+                accuracy_decimals=0,
+            ),
+            cv.Optional(CONF_RADON): sensor.sensor_schema(
+                unit_of_measurement=UNIT_BECQUEREL_PER_CUBIC_METER,
+                icon=ICON_RADIOACTIVE,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_RADON_LONG_TERM): sensor.sensor_schema(
+                unit_of_measurement=UNIT_BECQUEREL_PER_CUBIC_METER,
+                icon=ICON_RADIOACTIVE,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            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_PRESSURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_HECTOPASCAL,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_PRESSURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CO2): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_MILLION,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_CARBON_DIOXIDE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_TVOC): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PARTS_PER_BILLION,
+                icon=ICON_RADIATOR,
+                accuracy_decimals=0,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("5min"))
+    .extend(ble_client.BLE_CLIENT_SCHEMA),
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    await ble_client.register_ble_node(var, config)
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))
+    if CONF_RADON in config:
+        sens = await sensor.new_sensor(config[CONF_RADON])
+        cg.add(var.set_radon(sens))
+    if CONF_RADON_LONG_TERM in config:
+        sens = await sensor.new_sensor(config[CONF_RADON_LONG_TERM])
+        cg.add(var.set_radon_long_term(sens))
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+    if CONF_PRESSURE in config:
+        sens = await sensor.new_sensor(config[CONF_PRESSURE])
+        cg.add(var.set_pressure(sens))
+    if CONF_CO2 in config:
+        sens = await sensor.new_sensor(config[CONF_CO2])
+        cg.add(var.set_co2(sens))
+    if CONF_TVOC in config:
+        sens = await sensor.new_sensor(config[CONF_TVOC])
+        cg.add(var.set_tvoc(sens))

esphome/components/am2320/am2320.cpp

@@ -5,11 +5,12 @@
 
 #include "am2320.h"
 #include "esphome/core/log.h"
+#include "esphome/core/hal.h"
 
 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) {
@@ -18,12 +19,14 @@ uint16_t crc_16(uint8_t *ptr, uint8_t length) {
   //------------------------------
   while (length--) {
     crc ^= *ptr++;
-    for (i = 0; i < 8; i++)
+    for (i = 0; i < 8; i++) {
       if ((crc & 0x01) != 0) {
         crc >>= 1;
         crc ^= 0xA001;
-      } else
+      } else {
         crc >>= 1;
+      }
+    }
   }
   return crc;
 }
@@ -37,9 +40,9 @@ void AM2320Component::update() {
     return;
   }
 
-  float temperature = (((data[4] & 0x7F) << 8) + data[5]) / 10.0;
+  float temperature = (((data[4] & 0x7F) << 8) + data[5]) / 10.0f;
   temperature = (data[4] & 0x80) ? -temperature : temperature;
-  float humidity = ((data[2] << 8) + data[3]) / 10.0;
+  float humidity = ((data[2] << 8) + data[3]) / 10.0f;
 
   ESP_LOGD(TAG, "Got temperature=%.1f°C humidity=%.1f%%", temperature, humidity);
   if (this->temperature_sensor_ != nullptr)
@@ -77,7 +80,7 @@ bool AM2320Component::read_bytes_(uint8_t a_register, uint8_t *data, uint8_t len
 
   if (conversion > 0)
     delay(conversion);
-  return this->parent_->raw_receive(this->address_, data, len);
+  return this->read(data, len) == i2c::ERROR_OK;
 }
 
 bool AM2320Component::read_data_(uint8_t *data) {

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,117 @@
+#include "am43.h"
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace am43 {
+
+static const char *const 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_ = make_unique<Am43Encoder>();
+  this->decoder_ = make_unique<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 USE_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_;
+  std::unique_ptr<Am43Encoder> encoder_;
+  std::unique_ptr<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,144 @@
+#include "am43_base.h"
+#include <cstring>
+#include <cstdio>
+
+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", "sensor"]
+
+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,150 @@
+#include "am43_cover.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace am43 {
+
+static const char *const 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_ = make_unique<Am43Encoder>();
+  this->decoder_ = make_unique<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 USE_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_;
+  std::unique_ptr<Am43Encoder> encoder_;
+  std::unique_ptr<Am43Decoder> decoder_;
+  bool logged_in_;
+
+  float position_;
+};
+
+}  // namespace am43
+}  // namespace esphome
+
+#endif

esphome/components/am43/sensor.py

@@ -0,0 +1,52 @@
+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,
+    DEVICE_CLASS_BATTERY,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    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_of_measurement=UNIT_PERCENT,
+                device_class=DEVICE_CLASS_BATTERY,
+                accuracy_decimals=0,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                icon=ICON_BRIGHTNESS_5,
+                accuracy_decimals=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/analog_threshold/__init__.py

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

esphome/components/analog_threshold/analog_threshold_binary_sensor.cpp

@@ -0,0 +1,40 @@
+#include "analog_threshold_binary_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace analog_threshold {
+
+static const char *const TAG = "analog_threshold.binary_sensor";
+
+void AnalogThresholdBinarySensor::setup() {
+  float sensor_value = this->sensor_->get_state();
+
+  // TRUE state is defined to be when sensor is >= threshold
+  // so when undefined sensor value initialize to FALSE
+  if (std::isnan(sensor_value)) {
+    this->publish_initial_state(false);
+  } else {
+    this->publish_initial_state(sensor_value >= (this->lower_threshold_ + this->upper_threshold_) / 2.0f);
+  }
+}
+
+void AnalogThresholdBinarySensor::set_sensor(sensor::Sensor *analog_sensor) {
+  this->sensor_ = analog_sensor;
+
+  this->sensor_->add_on_state_callback([this](float sensor_value) {
+    // if there is an invalid sensor reading, ignore the change and keep the current state
+    if (!std::isnan(sensor_value)) {
+      this->publish_state(sensor_value >= (this->state ? this->lower_threshold_ : this->upper_threshold_));
+    }
+  });
+}
+
+void AnalogThresholdBinarySensor::dump_config() {
+  LOG_BINARY_SENSOR("", "Analog Threshold Binary Sensor", this);
+  LOG_SENSOR("  ", "Sensor", this->sensor_);
+  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_);
+  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_);
+}
+
+}  // namespace analog_threshold
+}  // namespace esphome

esphome/components/analog_threshold/analog_threshold_binary_sensor.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome {
+namespace analog_threshold {
+
+class AnalogThresholdBinarySensor : public Component, public binary_sensor::BinarySensor {
+ public:
+  void dump_config() override;
+  void setup() override;
+
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+  void set_sensor(sensor::Sensor *analog_sensor);
+  void set_upper_threshold(float threshold) { this->upper_threshold_ = threshold; }
+  void set_lower_threshold(float threshold) { this->lower_threshold_ = threshold; }
+
+ protected:
+  sensor::Sensor *sensor_{nullptr};
+
+  float upper_threshold_;
+  float lower_threshold_;
+};
+
+}  // namespace analog_threshold
+}  // namespace esphome

esphome/components/analog_threshold/binary_sensor.py

@@ -0,0 +1,44 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import binary_sensor, sensor
+from esphome.const import (
+    CONF_SENSOR_ID,
+    CONF_THRESHOLD,
+)
+
+analog_threshold_ns = cg.esphome_ns.namespace("analog_threshold")
+
+AnalogThresholdBinarySensor = analog_threshold_ns.class_(
+    "AnalogThresholdBinarySensor", binary_sensor.BinarySensor, cg.Component
+)
+
+CONF_UPPER = "upper"
+CONF_LOWER = "lower"
+
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(AnalogThresholdBinarySensor),
+        cv.Required(CONF_SENSOR_ID): cv.use_id(sensor.Sensor),
+        cv.Required(CONF_THRESHOLD): cv.Any(
+            cv.float_,
+            cv.Schema(
+                {cv.Required(CONF_UPPER): cv.float_, cv.Required(CONF_LOWER): cv.float_}
+            ),
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = await binary_sensor.new_binary_sensor(config)
+    await cg.register_component(var, config)
+
+    sens = await cg.get_variable(config[CONF_SENSOR_ID])
+    cg.add(var.set_sensor(sens))
+
+    if isinstance(config[CONF_THRESHOLD], float):
+        cg.add(var.set_upper_threshold(config[CONF_THRESHOLD]))
+        cg.add(var.set_lower_threshold(config[CONF_THRESHOLD]))
+    else:
+        cg.add(var.set_upper_threshold(config[CONF_THRESHOLD][CONF_UPPER]))
+        cg.add(var.set_lower_threshold(config[CONF_THRESHOLD][CONF_LOWER]))

esphome/components/animation/__init__.py

@@ -0,0 +1,144 @@
+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_RAW_DATA_ID, CONF_RESIZE, CONF_TYPE
+from esphome.core import CORE, HexInt
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ["display"]
+MULTI_CONF = True
+
+Animation_ = display.display_ns.class_("Animation")
+
+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:
+        new_width_max, new_height_max = config[CONF_RESIZE]
+        ratio = min(new_width_max / width, new_height_max / height)
+        width, height = int(width * ratio), int(height * ratio)
+    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)
+            if CONF_RESIZE in config:
+                frame = frame.resize([width, height])
+            pixels = list(frame.getdata())
+            if len(pixels) != height * width:
+                raise core.EsphomeError(
+                    f"Unexpected number of pixels in {path} frame {frameIndex}: ({len(pixels)} != {height*width})"
+                )
+            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)
+            if CONF_RESIZE in config:
+                image.thumbnail(config[CONF_RESIZE])
+            frame = image.convert("RGB")
+            if CONF_RESIZE in config:
+                frame = frame.resize([width, height])
+            pixels = list(frame.getdata())
+            if len(pixels) != height * width:
+                raise core.EsphomeError(
+                    f"Unexpected number of pixels in {path} frame {frameIndex}: ({len(pixels)} != {height*width})"
+                )
+            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] == "RGB565":
+        data = [0 for _ in range(height * width * 2 * frames)]
+        pos = 0
+        for frameIndex in range(frames):
+            image.seek(frameIndex)
+            frame = image.convert("RGB")
+            if CONF_RESIZE in config:
+                frame = frame.resize([width, height])
+            pixels = list(frame.getdata())
+            if len(pixels) != height * width:
+                raise core.EsphomeError(
+                    f"Unexpected number of pixels in {path} frame {frameIndex}: ({len(pixels)} != {height*width})"
+                )
+            for pix in pixels:
+                R = pix[0] >> 3
+                G = pix[1] >> 2
+                B = pix[2] >> 3
+                rgb = (R << 11) | (G << 5) | B
+                data[pos] = rgb >> 8
+                pos += 1
+                data[pos] = rgb & 255
+                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)
+            if CONF_RESIZE in config:
+                frame = frame.resize([width, height])
+            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,151 @@
+#include "anova.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace anova {
+
+static const char *const TAG = "anova";
+
+using namespace esphome::climate;
+
+void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
+
+void Anova::setup() {
+  this->codec_ = make_unique<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)
+      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 USE_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() override {
+    auto traits = climate::ClimateTraits();
+    traits.set_supports_current_temperature(true);
+    traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::ClimateMode::CLIMATE_MODE_HEAT});
+    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 *unit);
+
+ protected:
+  std::unique_ptr<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,134 @@
+#include "anova_base.h"
+#include <cstdio>
+#include <cstring>
+
+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) {
+  char buf[32];
+  memset(buf, 0, sizeof(buf));
+  strncpy(buf, (char *) data, std::min<uint16_t>(length, sizeof(buf) - 1));
+  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(buf, "stopped", 7)) {
+        this->has_running_ = true;
+        this->running_ = false;
+      }
+      if (!strncmp(buf, "running", 7)) {
+        this->has_running_ = true;
+        this->running_ = true;
+      }
+      break;
+    }
+    case START: {
+      if (!strncmp(buf, "start", 5)) {
+        this->has_running_ = true;
+        this->running_ = true;
+      }
+      break;
+    }
+    case STOP: {
+      if (!strncmp(buf, "stop", 4)) {
+        this->has_running_ = true;
+        this->running_ = false;
+      }
+      break;
+    }
+    case READ_TARGET_TEMPERATURE:
+    case SET_TARGET_TEMPERATURE: {
+      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
+      if (this->fahrenheit_)
+        this->target_temp_ = ftoc(this->target_temp_);
+      this->has_target_temp_ = true;
+      break;
+    }
+    case READ_CURRENT_TEMPERATURE: {
+      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
+      if (this->fahrenheit_)
+        this->current_temp_ = ftoc(this->current_temp_);
+      this->has_current_temp_ = true;
+      break;
+    }
+    case SET_UNIT:
+    case READ_UNIT: {
+      this->unit_ = buf[0];
+      this->fahrenheit_ = buf[0] == 'f';
+      this->has_unit_ = true;
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+}  // namespace anova
+}  // namespace esphome

esphome/components/anova/anova_base.h

@@ -0,0 +1,79 @@
+#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_;
+  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

@@ -1,13 +1,14 @@
 #include "apds9960.h"
 #include "esphome/core/log.h"
+#include "esphome/core/hal.h"
 
 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; \
   }
@@ -224,9 +225,10 @@ void APDS9960::read_gesture_data_() {
 
   uint8_t fifo_level;
   APDS9960_WARNING_CHECK(this->read_byte(0xAE, &fifo_level), "Reading FIFO level failed.");
-  if (fifo_level == 0)
+  if (fifo_level == 0) {
     // no data to process
     return;
+  }
 
   APDS9960_WARNING_CHECK(fifo_level <= 32, "FIFO level has invalid value.")
 

esphome/components/apds9960/binary_sensor.py

@@ -1,27 +1,30 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import binary_sensor
-from esphome.const import CONF_DIRECTION, CONF_DEVICE_CLASS, DEVICE_CLASS_MOVING
+from esphome.const import CONF_DIRECTION, 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(
+    device_class=DEVICE_CLASS_MOVING
+).extend(
+    {
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+        cv.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True),
+    }
+)
 
 
-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

@@ -1,52 +1,100 @@
+import base64
+
 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
+from esphome.const import (
+    CONF_DATA,
+    CONF_DATA_TEMPLATE,
+    CONF_ID,
+    CONF_KEY,
+    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 = ["socket"]
+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),
 }
+CONF_ENCRYPTION = "encryption"
 
-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)
+
+def validate_encryption_key(value):
+    value = cv.string_strict(value)
+    try:
+        decoded = base64.b64decode(value, validate=True)
+    except ValueError as err:
+        raise cv.Invalid("Invalid key format, please check it's using base64") from err
+
+    if len(decoded) != 32:
+        raise cv.Invalid("Encryption key must be base64 and 32 bytes long")
+
+    # Return original data for roundtrip conversion
+    return value
+
+
+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
+                        ),
+                    }
+                ),
+            }
+        ),
+        cv.Optional(CONF_ENCRYPTION): cv.Schema(
+            {
+                cv.Required(CONF_KEY): validate_encryption_key,
+            }
+        ),
+    }
+).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]))
@@ -62,81 +110,128 @@ 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')
+    if CONF_ENCRYPTION in config:
+        conf = config[CONF_ENCRYPTION]
+        decoded = base64.b64decode(conf[CONF_KEY])
+        cg.add(var.set_noise_psk(list(decoded)))
+        cg.add_define("USE_API_NOISE")
+        cg.add_library("esphome/noise-c", "0.1.4")
+    else:
+        cg.add_define("USE_API_PLAINTEXT")
+
+    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
 
 
-@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)
+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,
+)
+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 = 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, {})
+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,11 @@ 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) {}
+  rpc button_command (ButtonCommandRequest) returns (void) {}
+  rpc lock_command (LockCommandRequest) returns (void) {}
+  rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
 }
 
 
@@ -46,6 +51,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
@@ -91,6 +97,9 @@ message HelloResponse {
   // and only exists for debugging/logging purposes.
   // For example "ESPHome v1.10.0 on ESP8266"
   string server_info = 3;
+
+  // The name of the server (App.get_name())
+  string name = 4;
 }
 
 // Message sent at the beginning of each connection to authenticate the client
@@ -175,6 +184,12 @@ message DeviceInfoResponse {
   string model = 6;
 
   bool has_deep_sleep = 7;
+
+  // The esphome project details if set
+  string project_name = 8;
+  string project_version = 9;
+
+  uint32 webserver_port = 10;
 }
 
 message ListEntitiesRequest {
@@ -194,6 +209,14 @@ message SubscribeStatesRequest {
   // Empty
 }
 
+// ==================== COMMON =====================
+
+enum EntityCategory {
+  ENTITY_CATEGORY_NONE = 0;
+  ENTITY_CATEGORY_CONFIG = 1;
+  ENTITY_CATEGORY_DIAGNOSTIC = 2;
+}
+
 // ==================== BINARY SENSOR ====================
 message ListEntitiesBinarySensorResponse {
   option (id) = 12;
@@ -207,6 +230,9 @@ message ListEntitiesBinarySensorResponse {
 
   string device_class = 5;
   bool is_status_binary_sensor = 6;
+  bool disabled_by_default = 7;
+  string icon = 8;
+  EntityCategory entity_category = 9;
 }
 message BinarySensorStateResponse {
   option (id) = 21;
@@ -236,6 +262,9 @@ message ListEntitiesCoverResponse {
   bool supports_position = 6;
   bool supports_tilt = 7;
   string device_class = 8;
+  bool disabled_by_default = 9;
+  string icon = 10;
+  EntityCategory entity_category = 11;
 }
 
 enum LegacyCoverState {
@@ -302,6 +331,10 @@ message ListEntitiesFanResponse {
   bool supports_oscillation = 5;
   bool supports_speed = 6;
   bool supports_direction = 7;
+  int32 supported_speed_count = 8;
+  bool disabled_by_default = 9;
+  string icon = 10;
+  EntityCategory entity_category = 11;
 }
 enum FanSpeed {
   FAN_SPEED_LOW = 0;
@@ -321,8 +354,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 +367,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 +400,18 @@ 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;
+  string icon = 14;
+  EntityCategory entity_category = 15;
 }
 message LightStateResponse {
   option (id) = 24;
@@ -369,11 +422,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 +444,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 +456,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 +469,18 @@ message LightCommandRequest {
 }
 
 // ==================== SENSOR ====================
+enum SensorStateClass {
+  STATE_CLASS_NONE = 0;
+  STATE_CLASS_MEASUREMENT = 1;
+  STATE_CLASS_TOTAL_INCREASING = 2;
+}
+
+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 +495,12 @@ message ListEntitiesSensorResponse {
   string unit_of_measurement = 6;
   int32 accuracy_decimals = 7;
   bool force_update = 8;
+  string device_class = 9;
+  SensorStateClass state_class = 10;
+  // Last reset type removed in 2021.9.0
+  SensorLastResetType legacy_last_reset_type = 11;
+  bool disabled_by_default = 12;
+  EntityCategory entity_category = 13;
 }
 message SensorStateResponse {
   option (id) = 25;
@@ -445,6 +528,9 @@ message ListEntitiesSwitchResponse {
 
   string icon = 5;
   bool assumed_state = 6;
+  bool disabled_by_default = 7;
+  EntityCategory entity_category = 8;
+  string device_class = 9;
 }
 message SwitchStateResponse {
   option (id) = 26;
@@ -477,6 +563,8 @@ message ListEntitiesTextSensorResponse {
   string unique_id = 4;
 
   string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
 }
 message TextSensorStateResponse {
   option (id) = 27;
@@ -497,9 +585,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 +603,6 @@ message SubscribeLogsResponse {
   option (no_delay) = false;
 
   LogLevel level = 1;
-  string tag = 2;
   string message = 3;
   bool send_failed = 4;
 }
@@ -555,6 +643,7 @@ message SubscribeHomeAssistantStateResponse {
   option (id) = 39;
   option (source) = SOURCE_SERVER;
   string entity_id = 1;
+  string attribute = 2;
 }
 
 message HomeAssistantStateResponse {
@@ -564,6 +653,7 @@ message HomeAssistantStateResponse {
 
   string entity_id = 1;
   string state = 2;
+  string attribute = 3;
 }
 
 // ==================== IMPORT TIME ====================
@@ -634,6 +724,9 @@ message ListEntitiesCameraResponse {
   fixed32 key = 2;
   string name = 3;
   string unique_id = 4;
+  bool disabled_by_default = 5;
+  string icon = 6;
+  EntityCategory entity_category = 7;
 }
 
 message CameraImageResponse {
@@ -658,11 +751,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 +773,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 +784,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 +810,18 @@ 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;
+  string icon = 19;
+  EntityCategory entity_category = 20;
 }
 message ClimateStateResponse {
   option (id) = 47;
@@ -723,10 +835,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 +859,242 @@ 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 ====================
+enum NumberMode {
+  NUMBER_MODE_AUTO = 0;
+  NUMBER_MODE_BOX = 1;
+  NUMBER_MODE_SLIDER = 2;
+}
+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;
+  EntityCategory entity_category = 10;
+  string unit_of_measurement = 11;
+  NumberMode mode = 12;
+}
+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;
+  EntityCategory entity_category = 8;
+}
+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;
+}
+
+
+// ==================== LOCK ====================
+enum LockState {
+  LOCK_STATE_NONE = 0;
+  LOCK_STATE_LOCKED = 1;
+  LOCK_STATE_UNLOCKED = 2;
+  LOCK_STATE_JAMMED = 3;
+  LOCK_STATE_LOCKING = 4;
+  LOCK_STATE_UNLOCKING = 5;
+}
+enum LockCommand  {
+  LOCK_UNLOCK = 0;
+  LOCK_LOCK = 1;
+  LOCK_OPEN = 2;
+}
+message ListEntitiesLockResponse {
+  option (id) = 58;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_LOCK";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+  bool assumed_state = 8;
+
+  bool supports_open = 9;
+  bool requires_code = 10;
+
+  // Not yet implemented:
+  string code_format = 11;
+}
+message LockStateResponse {
+  option (id) = 59;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_LOCK";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  LockState state = 2;
+}
+message LockCommandRequest {
+  option (id) = 60;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_LOCK";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  LockCommand command = 2;
+
+  // Not yet implemented:
+  bool has_code = 3;
+  string code = 4;
+}
+
+// ==================== BUTTON ====================
+message ListEntitiesButtonResponse {
+  option (id) = 61;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BUTTON";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+  string device_class = 8;
+}
+message ButtonCommandRequest {
+  option (id) = 62;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_BUTTON";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+}
+
+// ==================== MEDIA PLAYER ====================
+enum MediaPlayerState {
+  MEDIA_PLAYER_STATE_NONE = 0;
+  MEDIA_PLAYER_STATE_IDLE = 1;
+  MEDIA_PLAYER_STATE_PLAYING = 2;
+  MEDIA_PLAYER_STATE_PAUSED = 3;
+}
+enum MediaPlayerCommand {
+  MEDIA_PLAYER_COMMAND_PLAY = 0;
+  MEDIA_PLAYER_COMMAND_PAUSE = 1;
+  MEDIA_PLAYER_COMMAND_STOP = 2;
+  MEDIA_PLAYER_COMMAND_MUTE = 3;
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4;
+}
+message ListEntitiesMediaPlayerResponse {
+  option (id) = 63;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+
+  bool supports_pause = 8;
+}
+message MediaPlayerStateResponse {
+  option (id) = 64;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+  fixed32 key = 1;
+  MediaPlayerState state = 2;
+  float volume = 3;
+  bool muted = 4;
+}
+message MediaPlayerCommandRequest {
+  option (id) = 65;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_MEDIA_PLAYER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+
+  bool has_command = 2;
+  MediaPlayerCommand command = 3;
+
+  bool has_volume = 4;
+  float volume = 5;
+
+  bool has_media_url = 6;
+  string media_url = 7;
 }

esphome/components/api/api_connection.cpp

@@ -1,7 +1,10 @@
 #include "api_connection.h"
+#include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
-#include "esphome/core/util.h"
+#include "esphome/components/network/util.h"
 #include "esphome/core/version.h"
+#include "esphome/core/hal.h"
+#include <cerrno>
 
 #ifdef USE_DEEP_SLEEP
 #include "esphome/components/deep_sleep/deep_sleep_component.h"
@@ -13,145 +16,150 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.connection";
+static const char *const TAG = "api.connection";
+static const int ESP32_CAMERA_STOP_STREAM = 5000;
 
-APIConnection::APIConnection(AsyncClient *client, APIServer *parent)
-    : client_(client), parent_(parent), initial_state_iterator_(parent, this), list_entities_iterator_(parent, this) {
-  this->client_->onError([](void *s, AsyncClient *c, int8_t error) { ((APIConnection *) s)->on_error_(error); }, this);
-  this->client_->onDisconnect([](void *s, AsyncClient *c) { ((APIConnection *) s)->on_disconnect_(); }, this);
-  this->client_->onTimeout([](void *s, AsyncClient *c, uint32_t time) { ((APIConnection *) s)->on_timeout_(time); },
-                           this);
-  this->client_->onData([](void *s, AsyncClient *c, void *buf,
-                           size_t len) { ((APIConnection *) s)->on_data_(reinterpret_cast<uint8_t *>(buf), len); },
-                        this);
+APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *parent)
+    : parent_(parent), initial_state_iterator_(this), list_entities_iterator_(this) {
+  this->proto_write_buffer_.reserve(64);
 
-  this->send_buffer_.reserve(64);
-  this->recv_buffer_.reserve(32);
-  this->client_info_ = this->client_->remoteIP().toString().c_str();
+#if defined(USE_API_PLAINTEXT)
+  helper_ = std::unique_ptr<APIFrameHelper>{new APIPlaintextFrameHelper(std::move(sock))};
+#elif defined(USE_API_NOISE)
+  helper_ = std::unique_ptr<APIFrameHelper>{new APINoiseFrameHelper(std::move(sock), parent->get_noise_ctx())};
+#else
+#error "No frame helper defined"
+#endif
+}
+void APIConnection::start() {
   this->last_traffic_ = millis();
-}
-APIConnection::~APIConnection() { delete this->client_; }
-void APIConnection::on_error_(int8_t error) { this->remove_ = true; }
-void APIConnection::on_disconnect_() { this->remove_ = true; }
-void APIConnection::on_timeout_(uint32_t time) { this->on_fatal_error(); }
-void APIConnection::on_data_(uint8_t *buf, size_t len) {
-  if (len == 0 || buf == nullptr)
+
+  APIError err = helper_->init();
+  if (err != APIError::OK) {
+    on_fatal_error();
+    ESP_LOGW(TAG, "%s: Helper init failed: %s errno=%d", client_info_.c_str(), api_error_to_str(err), errno);
     return;
-  this->recv_buffer_.insert(this->recv_buffer_.end(), buf, buf + len);
-}
-void APIConnection::parse_recv_buffer_() {
-  if (this->recv_buffer_.empty() || this->remove_)
-    return;
-
-  while (!this->recv_buffer_.empty()) {
-    if (this->recv_buffer_[0] != 0x00) {
-      ESP_LOGW(TAG, "Invalid preamble from %s", this->client_info_.c_str());
-      this->on_fatal_error();
-      return;
-    }
-    uint32_t i = 1;
-    const uint32_t size = this->recv_buffer_.size();
-    uint32_t consumed;
-    auto msg_size_varint = ProtoVarInt::parse(&this->recv_buffer_[i], size - i, &consumed);
-    if (!msg_size_varint.has_value())
-      // not enough data there yet
-      return;
-    i += consumed;
-    uint32_t msg_size = msg_size_varint->as_uint32();
-
-    auto msg_type_varint = ProtoVarInt::parse(&this->recv_buffer_[i], size - i, &consumed);
-    if (!msg_type_varint.has_value())
-      // not enough data there yet
-      return;
-    i += consumed;
-    uint32_t msg_type = msg_type_varint->as_uint32();
-
-    if (size - i < msg_size)
-      // message body not fully received
-      return;
-
-    uint8_t *msg = &this->recv_buffer_[i];
-    this->read_message(msg_size, msg_type, msg);
-    if (this->remove_)
-      return;
-    // pop front
-    uint32_t total = i + msg_size;
-    this->recv_buffer_.erase(this->recv_buffer_.begin(), this->recv_buffer_.begin() + total);
-    this->last_traffic_ = millis();
   }
-}
-
-void APIConnection::disconnect_client() {
-  this->client_->close();
-  this->remove_ = true;
+  client_info_ = helper_->getpeername();
+  helper_->set_log_info(client_info_);
 }
 
 void APIConnection::loop() {
   if (this->remove_)
     return;
 
-  if (this->next_close_) {
-    this->disconnect_client();
-    return;
-  }
-
-  if (!network_is_connected()) {
+  if (!network::is_connected()) {
     // when network is disconnected force disconnect immediately
     // don't wait for timeout
     this->on_fatal_error();
+    ESP_LOGW(TAG, "%s: Network unavailable, disconnecting", client_info_.c_str());
     return;
   }
-  if (this->client_->disconnected()) {
-    // failsafe for disconnect logic
-    this->on_disconnect_();
+  if (this->next_close_) {
+    // requested a disconnect
+    this->helper_->close();
+    this->remove_ = true;
     return;
   }
-  this->parse_recv_buffer_();
+
+  APIError err = helper_->loop();
+  if (err != APIError::OK) {
+    on_fatal_error();
+    ESP_LOGW(TAG, "%s: Socket operation failed: %s errno=%d", client_info_.c_str(), api_error_to_str(err), errno);
+    return;
+  }
+  ReadPacketBuffer buffer;
+  err = helper_->read_packet(&buffer);
+  if (err == APIError::WOULD_BLOCK) {
+    // pass
+  } else if (err != APIError::OK) {
+    on_fatal_error();
+    if (err == APIError::SOCKET_READ_FAILED && errno == ECONNRESET) {
+      ESP_LOGW(TAG, "%s: Connection reset", client_info_.c_str());
+    } else if (err == APIError::CONNECTION_CLOSED) {
+      ESP_LOGW(TAG, "%s: Connection closed", client_info_.c_str());
+    } else {
+      ESP_LOGW(TAG, "%s: Reading failed: %s errno=%d", client_info_.c_str(), api_error_to_str(err), errno);
+    }
+    return;
+  } else {
+    this->last_traffic_ = millis();
+    // read a packet
+    this->read_message(buffer.data_len, buffer.type, &buffer.container[buffer.data_offset]);
+    if (this->remove_)
+      return;
+  }
 
   this->list_entities_iterator_.advance();
   this->initial_state_iterator_.advance();
 
   const uint32_t keepalive = 60000;
+  const uint32_t now = millis();
   if (this->sent_ping_) {
     // Disconnect if not responded within 2.5*keepalive
-    if (millis() - this->last_traffic_ > (keepalive * 5) / 2) {
-      ESP_LOGW(TAG, "'%s' didn't respond to ping request in time. Disconnecting...", this->client_info_.c_str());
-      this->disconnect_client();
+    if (now - this->last_traffic_ > (keepalive * 5) / 2) {
+      on_fatal_error();
+      ESP_LOGW(TAG, "%s didn't respond to ping request in time. Disconnecting...", this->client_info_.c_str());
     }
-  } else if (millis() - this->last_traffic_ > keepalive) {
+  } else if (now - this->last_traffic_ > keepalive) {
+    ESP_LOGVV(TAG, "Sending keepalive PING...");
     this->sent_ping_ = true;
     this->send_ping_request(PingRequest());
   }
 
 #ifdef USE_ESP32_CAMERA
-  if (this->image_reader_.available()) {
-    uint32_t space = this->client_->space();
-    // reserve 15 bytes for metadata, and at least 64 bytes of data
-    if (space >= 15 + 64) {
-      uint32_t to_send = std::min(space - 15, this->image_reader_.available());
-      auto buffer = this->create_buffer();
-      // fixed32 key = 1;
-      buffer.encode_fixed32(1, esp32_camera::global_esp32_camera->get_object_id_hash());
-      // bytes data = 2;
-      buffer.encode_bytes(2, this->image_reader_.peek_data_buffer(), to_send);
-      // bool done = 3;
-      bool done = this->image_reader_.available() == to_send;
-      buffer.encode_bool(3, done);
-      bool success = this->send_buffer(buffer, 44);
+  if (this->image_reader_.available() && this->helper_->can_write_without_blocking()) {
+    uint32_t to_send = std::min((size_t) 1024, this->image_reader_.available());
+    auto buffer = this->create_buffer();
+    // fixed32 key = 1;
+    buffer.encode_fixed32(1, esp32_camera::global_esp32_camera->get_object_id_hash());
+    // bytes data = 2;
+    buffer.encode_bytes(2, this->image_reader_.peek_data_buffer(), to_send);
+    // bool done = 3;
+    bool done = this->image_reader_.available() == to_send;
+    buffer.encode_bool(3, done);
+    bool success = this->send_buffer(buffer, 44);
 
-      if (success) {
-        this->image_reader_.consume_data(to_send);
-      }
-      if (success && done) {
-        this->image_reader_.return_image();
-      }
+    if (success) {
+      this->image_reader_.consume_data(to_send);
+    }
+    if (success && done) {
+      this->image_reader_.return_image();
     }
   }
 #endif
+
+  if (state_subs_at_ != -1) {
+    const auto &subs = this->parent_->get_state_subs();
+    if (state_subs_at_ >= (int) subs.size()) {
+      state_subs_at_ = -1;
+    } else {
+      auto &it = subs[state_subs_at_];
+      SubscribeHomeAssistantStateResponse resp;
+      resp.entity_id = it.entity_id;
+      resp.attribute = it.attribute.value();
+      if (this->send_subscribe_home_assistant_state_response(resp)) {
+        state_subs_at_++;
+      }
+    }
+  }
 }
 
-std::string get_default_unique_id(const std::string &component_type, Nameable *nameable) {
-  return App.get_name() + component_type + nameable->get_object_id();
+std::string get_default_unique_id(const std::string &component_type, EntityBase *entity) {
+  return App.get_name() + component_type + entity->get_object_id();
+}
+
+DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
+  // remote initiated disconnect_client
+  // don't close yet, we still need to send the disconnect response
+  // close will happen on next loop
+  ESP_LOGD(TAG, "%s requested disconnected", client_info_.c_str());
+  this->next_close_ = true;
+  DisconnectResponse resp;
+  return resp;
+}
+void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
+  // pass
 }
 
 #ifdef USE_BINARY_SENSOR
@@ -173,6 +181,9 @@ 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();
+  msg.icon = binary_sensor->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(binary_sensor->get_entity_category());
   return this->send_list_entities_binary_sensor_response(msg);
 }
 #endif
@@ -204,6 +215,9 @@ 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();
+  msg.icon = cover->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(cover->get_entity_category());
   return this->send_list_entities_cover_response(msg);
 }
 void APIConnection::cover_command(const CoverCommandRequest &msg) {
@@ -236,7 +250,7 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 #endif
 
 #ifdef USE_FAN
-bool APIConnection::send_fan_state(fan::FanState *fan) {
+bool APIConnection::send_fan_state(fan::Fan *fan) {
   if (!this->state_subscription_)
     return false;
 
@@ -246,13 +260,14 @@ 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;
+  }
   if (traits.supports_direction())
     resp.direction = static_cast<enums::FanDirection>(fan->direction);
   return this->send_fan_state_response(resp);
 }
-bool APIConnection::send_fan_info(fan::FanState *fan) {
+bool APIConnection::send_fan_info(fan::Fan *fan) {
   auto traits = fan->get_traits();
   ListEntitiesFanResponse msg;
   msg.key = fan->get_object_id_hash();
@@ -262,10 +277,14 @@ 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();
+  msg.icon = fan->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(fan->get_entity_category());
   return this->send_list_entities_fan_response(msg);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
-  fan::FanState *fan = App.get_fan_by_key(msg.key);
+  fan::Fan *fan = App.get_fan_by_key(msg.key);
   if (fan == nullptr)
     return;
 
@@ -274,8 +293,10 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
     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);
+  }
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   call.perform();
@@ -289,21 +310,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 +336,23 @@ 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();
+  msg.icon = light->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(light->get_entity_category());
+
+  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 +373,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 +386,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 +423,10 @@ 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->get_state_class());
+  msg.disabled_by_default = sensor->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(sensor->get_entity_category());
   return this->send_list_entities_sensor_response(msg);
 }
 #endif
@@ -404,6 +449,9 @@ 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();
+  msg.entity_category = static_cast<enums::EntityCategory>(a_switch->get_entity_category());
+  msg.device_class = a_switch->get_device_class();
   return this->send_list_entities_switch_response(msg);
 }
 void APIConnection::switch_command(const SwitchCommandRequest &msg) {
@@ -411,10 +459,11 @@ void APIConnection::switch_command(const SwitchCommandRequest &msg) {
   if (a_switch == nullptr)
     return;
 
-  if (msg.state)
+  if (msg.state) {
     a_switch->turn_on();
-  else
+  } else {
     a_switch->turn_off();
+  }
 }
 #endif
 
@@ -438,6 +487,8 @@ 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();
+  msg.entity_category = static_cast<enums::EntityCategory>(text_sensor->get_entity_category());
   return this->send_list_entities_text_sensor_response(msg);
 }
 #endif
@@ -460,10 +511,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 +532,33 @@ 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.icon = climate->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(climate->get_entity_category());
+
   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,23 +575,219 @@ 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->get_icon();
+  msg.disabled_by_default = number->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(number->get_entity_category());
+  msg.unit_of_measurement = number->traits.get_unit_of_measurement();
+  msg.mode = static_cast<enums::NumberMode>(number->traits.get_mode());
+
+  msg.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->get_icon();
+  msg.disabled_by_default = select->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(select->get_entity_category());
+
+  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_BUTTON
+bool APIConnection::send_button_info(button::Button *button) {
+  ListEntitiesButtonResponse msg;
+  msg.key = button->get_object_id_hash();
+  msg.object_id = button->get_object_id();
+  msg.name = button->get_name();
+  msg.unique_id = get_default_unique_id("button", button);
+  msg.icon = button->get_icon();
+  msg.disabled_by_default = button->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(button->get_entity_category());
+  msg.device_class = button->get_device_class();
+  return this->send_list_entities_button_response(msg);
+}
+void APIConnection::button_command(const ButtonCommandRequest &msg) {
+  button::Button *button = App.get_button_by_key(msg.key);
+  if (button == nullptr)
+    return;
+
+  button->press();
+}
+#endif
+
+#ifdef USE_LOCK
+bool APIConnection::send_lock_state(lock::Lock *a_lock, lock::LockState state) {
+  if (!this->state_subscription_)
+    return false;
+
+  LockStateResponse resp{};
+  resp.key = a_lock->get_object_id_hash();
+  resp.state = static_cast<enums::LockState>(state);
+  return this->send_lock_state_response(resp);
+}
+bool APIConnection::send_lock_info(lock::Lock *a_lock) {
+  ListEntitiesLockResponse msg;
+  msg.key = a_lock->get_object_id_hash();
+  msg.object_id = a_lock->get_object_id();
+  msg.name = a_lock->get_name();
+  msg.unique_id = get_default_unique_id("lock", a_lock);
+  msg.icon = a_lock->get_icon();
+  msg.assumed_state = a_lock->traits.get_assumed_state();
+  msg.disabled_by_default = a_lock->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(a_lock->get_entity_category());
+  msg.supports_open = a_lock->traits.get_supports_open();
+  msg.requires_code = a_lock->traits.get_requires_code();
+  return this->send_list_entities_lock_response(msg);
+}
+void APIConnection::lock_command(const LockCommandRequest &msg) {
+  lock::Lock *a_lock = App.get_lock_by_key(msg.key);
+  if (a_lock == nullptr)
+    return;
+
+  switch (msg.command) {
+    case enums::LOCK_UNLOCK:
+      a_lock->unlock();
+      break;
+    case enums::LOCK_LOCK:
+      a_lock->lock();
+      break;
+    case enums::LOCK_OPEN:
+      a_lock->open();
+      break;
+  }
+}
+#endif
+
+#ifdef USE_MEDIA_PLAYER
+bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
+  if (!this->state_subscription_)
+    return false;
+
+  MediaPlayerStateResponse resp{};
+  resp.key = media_player->get_object_id_hash();
+  resp.state = static_cast<enums::MediaPlayerState>(media_player->state);
+  resp.volume = media_player->volume;
+  resp.muted = media_player->is_muted();
+  return this->send_media_player_state_response(resp);
+}
+bool APIConnection::send_media_player_info(media_player::MediaPlayer *media_player) {
+  ListEntitiesMediaPlayerResponse msg;
+  msg.key = media_player->get_object_id_hash();
+  msg.object_id = media_player->get_object_id();
+  msg.name = media_player->get_name();
+  msg.unique_id = get_default_unique_id("media_player", media_player);
+  msg.icon = media_player->get_icon();
+  msg.disabled_by_default = media_player->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(media_player->get_entity_category());
+
+  auto traits = media_player->get_traits();
+  msg.supports_pause = traits.get_supports_pause();
+
+  return this->send_list_entities_media_player_response(msg);
+}
+void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
+  media_player::MediaPlayer *media_player = App.get_media_player_by_key(msg.key);
+  if (media_player == nullptr)
+    return;
+
+  auto call = media_player->make_call();
+  if (msg.has_command) {
+    call.set_command(static_cast<media_player::MediaPlayerCommand>(msg.command));
+  }
+  if (msg.has_volume) {
+    call.set_volume(msg.volume);
+  }
+  if (msg.has_media_url) {
+    call.set_media_url(msg.media_url);
+  }
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)
     return;
   if (this->image_reader_.available())
     return;
-  this->image_reader_.set_image(image);
+  if (image->was_requested_by(esphome::esp32_camera::API_REQUESTER) ||
+      image->was_requested_by(esphome::esp32_camera::IDLE))
+    this->image_reader_.set_image(std::move(image));
 }
 bool APIConnection::send_camera_info(esp32_camera::ESP32Camera *camera) {
   ListEntitiesCameraResponse msg;
@@ -538,6 +795,9 @@ 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();
+  msg.icon = camera->get_icon();
+  msg.entity_category = static_cast<enums::EntityCategory>(camera->get_entity_category());
   return this->send_list_entities_camera_response(msg);
 }
 void APIConnection::camera_image(const CameraImageRequest &msg) {
@@ -545,9 +805,14 @@ void APIConnection::camera_image(const CameraImageRequest &msg) {
     return;
 
   if (msg.single)
-    esp32_camera::global_esp32_camera->request_image();
-  if (msg.stream)
-    esp32_camera::global_esp32_camera->request_stream();
+    esp32_camera::global_esp32_camera->request_image(esphome::esp32_camera::API_REQUESTER);
+  if (msg.stream) {
+    esp32_camera::global_esp32_camera->start_stream(esphome::esp32_camera::API_REQUESTER);
+
+    App.scheduler.set_timeout(this->parent_, "api_esp32_camera_stop_stream", ESP32_CAMERA_STOP_STREAM, []() {
+      esp32_camera::global_esp32_camera->stop_stream(esphome::esp32_camera::API_REQUESTER);
+    });
+  }
 }
 #endif
 
@@ -566,31 +831,23 @@ 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
-  bool success = this->send_buffer(buffer, 29);
-  if (!success) {
-    buffer = this->create_buffer();
-    // bool send_failed = 4;
-    buffer.encode_bool(4, true);
-    return this->send_buffer(buffer, 29);
-  } else {
-    return true;
-  }
+  return this->send_buffer(buffer, 29);
 }
 
 HelloResponse APIConnection::hello(const HelloRequest &msg) {
-  this->client_info_ = msg.client_info + " (" + this->client_->remoteIP().toString().c_str();
-  this->client_info_ += ")";
+  this->client_info_ = msg.client_info + " (" + this->helper_->getpeername() + ")";
+  this->helper_->set_log_info(client_info_);
   ESP_LOGV(TAG, "Hello from client: '%s'", this->client_info_.c_str());
 
   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 ")";
+  resp.name = App.get_name();
+
   this->connection_state_ = ConnectionState::CONNECTED;
   return resp;
 }
@@ -601,7 +858,7 @@ ConnectResponse APIConnection::connect(const ConnectRequest &msg) {
   // bool invalid_password = 1;
   resp.invalid_password = !correct;
   if (correct) {
-    ESP_LOGD(TAG, "Client '%s' connected successfully!", this->client_info_.c_str());
+    ESP_LOGD(TAG, "%s: Connected successfully", this->client_info_.c_str());
     this->connection_state_ = ConnectionState::AUTHENTICATED;
 
 #ifdef USE_HOMEASSISTANT_TIME
@@ -619,18 +876,25 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
   resp.mac_address = get_mac_address_pretty();
   resp.esphome_version = ESPHOME_VERSION;
   resp.compilation_time = App.get_compilation_time();
-#ifdef ARDUINO_BOARD
-  resp.model = ARDUINO_BOARD;
-#endif
+  resp.model = ESPHOME_BOARD;
 #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
+#ifdef USE_WEBSERVER
+  resp.webserver_port = USE_WEBSERVER_PORT;
 #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)
+  for (auto &it : this->parent_->get_state_subs()) {
+    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;
@@ -644,29 +908,20 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   }
 }
 void APIConnection::subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) {
-  for (auto &it : this->parent_->get_state_subs()) {
-    SubscribeHomeAssistantStateResponse resp;
-    resp.entity_id = it.entity_id;
-    if (!this->send_subscribe_home_assistant_state_response(resp)) {
-      this->on_fatal_error();
-      return;
-    }
-  }
+  state_subs_at_ = 0;
 }
 bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint32_t message_type) {
   if (this->remove_)
     return false;
-
-  std::vector<uint8_t> header;
-  header.push_back(0x00);
-  ProtoVarInt(buffer.get_buffer()->size()).encode(header);
-  ProtoVarInt(message_type).encode(header);
-
-  size_t needed_space = buffer.get_buffer()->size() + header.size();
-
-  if (needed_space > this->client_->space()) {
+  if (!this->helper_->can_write_without_blocking()) {
     delay(0);
-    if (needed_space > this->client_->space()) {
+    APIError err = helper_->loop();
+    if (err != APIError::OK) {
+      on_fatal_error();
+      ESP_LOGW(TAG, "%s: Socket operation failed: %s errno=%d", client_info_.c_str(), api_error_to_str(err), errno);
+      return false;
+    }
+    if (!this->helper_->can_write_without_blocking()) {
       // SubscribeLogsResponse
       if (message_type != 29) {
         ESP_LOGV(TAG, "Cannot send message because of TCP buffer space");
@@ -676,22 +931,31 @@ 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());
-  bool ret = this->client_->send();
-  return ret;
+  APIError err = this->helper_->write_packet(message_type, buffer.get_buffer()->data(), buffer.get_buffer()->size());
+  if (err == APIError::WOULD_BLOCK)
+    return false;
+  if (err != APIError::OK) {
+    on_fatal_error();
+    if (err == APIError::SOCKET_WRITE_FAILED && errno == ECONNRESET) {
+      ESP_LOGW(TAG, "%s: Connection reset", client_info_.c_str());
+    } else {
+      ESP_LOGW(TAG, "%s: Packet write failed %s errno=%d", client_info_.c_str(), api_error_to_str(err), errno);
+    }
+    return false;
+  }
+  // Do not set last_traffic_ on send
+  return true;
 }
 void APIConnection::on_unauthenticated_access() {
-  ESP_LOGD(TAG, "'%s' tried to access without authentication.", this->client_info_.c_str());
   this->on_fatal_error();
+  ESP_LOGD(TAG, "%s: tried to access without authentication.", this->client_info_.c_str());
 }
 void APIConnection::on_no_setup_connection() {
-  ESP_LOGD(TAG, "'%s' tried to access without full connection.", this->client_info_.c_str());
   this->on_fatal_error();
+  ESP_LOGD(TAG, "%s: tried to access without full connection.", this->client_info_.c_str());
 }
 void APIConnection::on_fatal_error() {
-  ESP_LOGV(TAG, "Error: Disconnecting %s", this->client_info_.c_str());
-  this->client_->close();
+  this->helper_->close();
   this->remove_ = true;
 }
 

esphome/components/api/api_connection.h

@@ -5,16 +5,17 @@
 #include "api_pb2.h"
 #include "api_pb2_service.h"
 #include "api_server.h"
+#include "api_frame_helper.h"
 
 namespace esphome {
 namespace api {
 
 class APIConnection : public APIServerConnection {
  public:
-  APIConnection(AsyncClient *client, APIServer *parent);
-  virtual ~APIConnection();
+  APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
+  virtual ~APIConnection() = default;
 
-  void disconnect_client();
+  void start();
   void loop();
 
   bool send_list_info_done() {
@@ -31,8 +32,8 @@ class APIConnection : public APIServerConnection {
   void cover_command(const CoverCommandRequest &msg) override;
 #endif
 #ifdef USE_FAN
-  bool send_fan_state(fan::FanState *fan);
-  bool send_fan_info(fan::FanState *fan);
+  bool send_fan_state(fan::Fan *fan);
+  bool send_fan_info(fan::Fan *fan);
   void fan_command(const FanCommandRequest &msg) override;
 #endif
 #ifdef USE_LIGHT
@@ -62,6 +63,30 @@ 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
+#ifdef USE_BUTTON
+  bool send_button_info(button::Button *button);
+  void button_command(const ButtonCommandRequest &msg) override;
+#endif
+#ifdef USE_LOCK
+  bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
+  bool send_lock_info(lock::Lock *a_lock);
+  void lock_command(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state(media_player::MediaPlayer *media_player);
+  bool send_media_player_info(media_player::MediaPlayer *media_player);
+  void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
   bool send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
@@ -76,10 +101,7 @@ class APIConnection : public APIServerConnection {
   }
 #endif
 
-  void on_disconnect_response(const DisconnectResponse &value) override {
-    // we initiated disconnect_client
-    this->next_close_ = true;
-  }
+  void on_disconnect_response(const DisconnectResponse &value) override;
   void on_ping_response(const PingResponse &value) override {
     // we initiated ping
     this->sent_ping_ = false;
@@ -90,12 +112,7 @@ class APIConnection : public APIServerConnection {
 #endif
   HelloResponse hello(const HelloRequest &msg) override;
   ConnectResponse connect(const ConnectRequest &msg) override;
-  DisconnectResponse disconnect(const DisconnectRequest &msg) override {
-    // remote initiated disconnect_client
-    this->next_close_ = true;
-    DisconnectResponse resp;
-    return resp;
-  }
+  DisconnectResponse disconnect(const DisconnectRequest &msg) override;
   PingResponse ping(const PingRequest &msg) override { return {}; }
   DeviceInfoResponse device_info(const DeviceInfoRequest &msg) override;
   void list_entities(const ListEntitiesRequest &msg) override { this->list_entities_iterator_.begin(); }
@@ -125,19 +142,16 @@ class APIConnection : public APIServerConnection {
   void on_unauthenticated_access() override;
   void on_no_setup_connection() override;
   ProtoWriteBuffer create_buffer() override {
-    this->send_buffer_.clear();
-    return {&this->send_buffer_};
+    // FIXME: ensure no recursive writes can happen
+    this->proto_write_buffer_.clear();
+    return {&this->proto_write_buffer_};
   }
   bool send_buffer(ProtoWriteBuffer buffer, uint32_t message_type) override;
 
  protected:
   friend APIServer;
 
-  void on_error_(int8_t error);
-  void on_disconnect_();
-  void on_timeout_(uint32_t time);
-  void on_data_(uint8_t *buf, size_t len);
-  void parse_recv_buffer_();
+  bool send_(const void *buf, size_t len, bool force);
 
   enum class ConnectionState {
     WAITING_FOR_HELLO,
@@ -147,8 +161,10 @@ class APIConnection : public APIServerConnection {
 
   bool remove_{false};
 
-  std::vector<uint8_t> send_buffer_;
-  std::vector<uint8_t> recv_buffer_;
+  // Buffer used to encode proto messages
+  // Re-use to prevent allocations
+  std::vector<uint8_t> proto_write_buffer_;
+  std::unique_ptr<APIFrameHelper> helper_;
 
   std::string client_info_;
 #ifdef USE_ESP32_CAMERA
@@ -160,12 +176,11 @@ class APIConnection : public APIServerConnection {
   uint32_t last_traffic_;
   bool sent_ping_{false};
   bool service_call_subscription_{false};
-  bool current_nodelay_{false};
-  bool next_close_{false};
-  AsyncClient *client_;
+  bool next_close_ = false;
   APIServer *parent_;
   InitialStateIterator initial_state_iterator_;
   ListEntitiesIterator list_entities_iterator_;
+  int state_subs_at_ = -1;
 };
 
 }  // namespace api

esphome/components/api/api_frame_helper.cpp

@@ -0,0 +1,1024 @@
+#include "api_frame_helper.h"
+
+#include "esphome/core/log.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/application.h"
+#include "proto.h"
+#include <cstring>
+
+namespace esphome {
+namespace api {
+
+static const char *const TAG = "api.socket";
+
+/// Is the given return value (from write syscalls) a wouldblock error?
+bool is_would_block(ssize_t ret) {
+  if (ret == -1) {
+    return errno == EWOULDBLOCK || errno == EAGAIN;
+  }
+  return ret == 0;
+}
+
+const char *api_error_to_str(APIError err) {
+  // not using switch to ensure compiler doesn't try to build a big table out of it
+  if (err == APIError::OK) {
+    return "OK";
+  } else if (err == APIError::WOULD_BLOCK) {
+    return "WOULD_BLOCK";
+  } else if (err == APIError::BAD_HANDSHAKE_PACKET_LEN) {
+    return "BAD_HANDSHAKE_PACKET_LEN";
+  } else if (err == APIError::BAD_INDICATOR) {
+    return "BAD_INDICATOR";
+  } else if (err == APIError::BAD_DATA_PACKET) {
+    return "BAD_DATA_PACKET";
+  } else if (err == APIError::TCP_NODELAY_FAILED) {
+    return "TCP_NODELAY_FAILED";
+  } else if (err == APIError::TCP_NONBLOCKING_FAILED) {
+    return "TCP_NONBLOCKING_FAILED";
+  } else if (err == APIError::CLOSE_FAILED) {
+    return "CLOSE_FAILED";
+  } else if (err == APIError::SHUTDOWN_FAILED) {
+    return "SHUTDOWN_FAILED";
+  } else if (err == APIError::BAD_STATE) {
+    return "BAD_STATE";
+  } else if (err == APIError::BAD_ARG) {
+    return "BAD_ARG";
+  } else if (err == APIError::SOCKET_READ_FAILED) {
+    return "SOCKET_READ_FAILED";
+  } else if (err == APIError::SOCKET_WRITE_FAILED) {
+    return "SOCKET_WRITE_FAILED";
+  } else if (err == APIError::HANDSHAKESTATE_READ_FAILED) {
+    return "HANDSHAKESTATE_READ_FAILED";
+  } else if (err == APIError::HANDSHAKESTATE_WRITE_FAILED) {
+    return "HANDSHAKESTATE_WRITE_FAILED";
+  } else if (err == APIError::HANDSHAKESTATE_BAD_STATE) {
+    return "HANDSHAKESTATE_BAD_STATE";
+  } else if (err == APIError::CIPHERSTATE_DECRYPT_FAILED) {
+    return "CIPHERSTATE_DECRYPT_FAILED";
+  } else if (err == APIError::CIPHERSTATE_ENCRYPT_FAILED) {
+    return "CIPHERSTATE_ENCRYPT_FAILED";
+  } else if (err == APIError::OUT_OF_MEMORY) {
+    return "OUT_OF_MEMORY";
+  } else if (err == APIError::HANDSHAKESTATE_SETUP_FAILED) {
+    return "HANDSHAKESTATE_SETUP_FAILED";
+  } else if (err == APIError::HANDSHAKESTATE_SPLIT_FAILED) {
+    return "HANDSHAKESTATE_SPLIT_FAILED";
+  } else if (err == APIError::BAD_HANDSHAKE_ERROR_BYTE) {
+    return "BAD_HANDSHAKE_ERROR_BYTE";
+  } else if (err == APIError::CONNECTION_CLOSED) {
+    return "CONNECTION_CLOSED";
+  }
+  return "UNKNOWN";
+}
+
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s: " msg, info_.c_str(), ##__VA_ARGS__)
+// uncomment to log raw packets
+//#define HELPER_LOG_PACKETS
+
+#ifdef USE_API_NOISE
+static const char *const PROLOGUE_INIT = "NoiseAPIInit";
+
+/// Convert a noise error code to a readable error
+std::string noise_err_to_str(int err) {
+  if (err == NOISE_ERROR_NO_MEMORY)
+    return "NO_MEMORY";
+  if (err == NOISE_ERROR_UNKNOWN_ID)
+    return "UNKNOWN_ID";
+  if (err == NOISE_ERROR_UNKNOWN_NAME)
+    return "UNKNOWN_NAME";
+  if (err == NOISE_ERROR_MAC_FAILURE)
+    return "MAC_FAILURE";
+  if (err == NOISE_ERROR_NOT_APPLICABLE)
+    return "NOT_APPLICABLE";
+  if (err == NOISE_ERROR_SYSTEM)
+    return "SYSTEM";
+  if (err == NOISE_ERROR_REMOTE_KEY_REQUIRED)
+    return "REMOTE_KEY_REQUIRED";
+  if (err == NOISE_ERROR_LOCAL_KEY_REQUIRED)
+    return "LOCAL_KEY_REQUIRED";
+  if (err == NOISE_ERROR_PSK_REQUIRED)
+    return "PSK_REQUIRED";
+  if (err == NOISE_ERROR_INVALID_LENGTH)
+    return "INVALID_LENGTH";
+  if (err == NOISE_ERROR_INVALID_PARAM)
+    return "INVALID_PARAM";
+  if (err == NOISE_ERROR_INVALID_STATE)
+    return "INVALID_STATE";
+  if (err == NOISE_ERROR_INVALID_NONCE)
+    return "INVALID_NONCE";
+  if (err == NOISE_ERROR_INVALID_PRIVATE_KEY)
+    return "INVALID_PRIVATE_KEY";
+  if (err == NOISE_ERROR_INVALID_PUBLIC_KEY)
+    return "INVALID_PUBLIC_KEY";
+  if (err == NOISE_ERROR_INVALID_FORMAT)
+    return "INVALID_FORMAT";
+  if (err == NOISE_ERROR_INVALID_SIGNATURE)
+    return "INVALID_SIGNATURE";
+  return to_string(err);
+}
+
+/// Initialize the frame helper, returns OK if successful.
+APIError APINoiseFrameHelper::init() {
+  if (state_ != State::INITIALIZE || socket_ == nullptr) {
+    HELPER_LOG("Bad state for init %d", (int) state_);
+    return APIError::BAD_STATE;
+  }
+  int err = socket_->setblocking(false);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("Setting nonblocking failed with errno %d", errno);
+    return APIError::TCP_NONBLOCKING_FAILED;
+  }
+
+  int enable = 1;
+  err = socket_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(int));
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("Setting nodelay failed with errno %d", errno);
+    return APIError::TCP_NODELAY_FAILED;
+  }
+
+  // init prologue
+  prologue_.insert(prologue_.end(), PROLOGUE_INIT, PROLOGUE_INIT + strlen(PROLOGUE_INIT));
+
+  state_ = State::CLIENT_HELLO;
+  return APIError::OK;
+}
+/// Run through handshake messages (if in that phase)
+APIError APINoiseFrameHelper::loop() {
+  APIError err = state_action_();
+  if (err == APIError::WOULD_BLOCK)
+    return APIError::OK;
+  if (err != APIError::OK)
+    return err;
+  if (!tx_buf_.empty()) {
+    err = try_send_tx_buf_();
+    if (err != APIError::OK) {
+      return err;
+    }
+  }
+  return APIError::OK;
+}
+
+/** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
+ *
+ * @param frame: The struct to hold the frame information in.
+ *   msg_start: points to the start of the payload - this pointer is only valid until the next
+ *     try_receive_raw_ call
+ *
+ * @return 0 if a full packet is in rx_buf_
+ * @return -1 if error, check errno.
+ *
+ * errno EWOULDBLOCK: Packet could not be read without blocking. Try again later.
+ * errno ENOMEM: Not enough memory for reading packet.
+ * errno API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
+ * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
+ */
+APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
+  if (frame == nullptr) {
+    HELPER_LOG("Bad argument for try_read_frame_");
+    return APIError::BAD_ARG;
+  }
+
+  // read header
+  if (rx_header_buf_len_ < 3) {
+    // no header information yet
+    size_t to_read = 3 - rx_header_buf_len_;
+    ssize_t received = socket_->read(&rx_header_buf_[rx_header_buf_len_], to_read);
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
+    }
+    rx_header_buf_len_ += received;
+    if ((size_t) received != to_read) {
+      // not a full read
+      return APIError::WOULD_BLOCK;
+    }
+
+    // header reading done
+  }
+
+  // read body
+  uint8_t indicator = rx_header_buf_[0];
+  if (indicator != 0x01) {
+    state_ = State::FAILED;
+    HELPER_LOG("Bad indicator byte %u", indicator);
+    return APIError::BAD_INDICATOR;
+  }
+
+  uint16_t msg_size = (((uint16_t) rx_header_buf_[1]) << 8) | rx_header_buf_[2];
+
+  if (state_ != State::DATA && msg_size > 128) {
+    // for handshake message only permit up to 128 bytes
+    state_ = State::FAILED;
+    HELPER_LOG("Bad packet len for handshake: %d", msg_size);
+    return APIError::BAD_HANDSHAKE_PACKET_LEN;
+  }
+
+  // reserve space for body
+  if (rx_buf_.size() != msg_size) {
+    rx_buf_.resize(msg_size);
+  }
+
+  if (rx_buf_len_ < msg_size) {
+    // more data to read
+    size_t to_read = msg_size - rx_buf_len_;
+    ssize_t received = socket_->read(&rx_buf_[rx_buf_len_], to_read);
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
+    }
+    rx_buf_len_ += received;
+    if ((size_t) received != to_read) {
+      // not all read
+      return APIError::WOULD_BLOCK;
+    }
+  }
+
+  // uncomment for even more debugging
+#ifdef HELPER_LOG_PACKETS
+  ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(rx_buf_).c_str());
+#endif
+  frame->msg = std::move(rx_buf_);
+  // consume msg
+  rx_buf_ = {};
+  rx_buf_len_ = 0;
+  rx_header_buf_len_ = 0;
+  return APIError::OK;
+}
+
+/** To be called from read/write methods.
+ *
+ * This method runs through the internal handshake methods, if in that state.
+ *
+ * If the handshake is still active when this method returns and a read/write can't take place at
+ * the moment, returns WOULD_BLOCK.
+ * If an error occured, returns that error. Only returns OK if the transport is ready for data
+ * traffic.
+ */
+APIError APINoiseFrameHelper::state_action_() {
+  int err;
+  APIError aerr;
+  if (state_ == State::INITIALIZE) {
+    HELPER_LOG("Bad state for method: %d", (int) state_);
+    return APIError::BAD_STATE;
+  }
+  if (state_ == State::CLIENT_HELLO) {
+    // waiting for client hello
+    ParsedFrame frame;
+    aerr = try_read_frame_(&frame);
+    if (aerr == APIError::BAD_INDICATOR) {
+      send_explicit_handshake_reject_("Bad indicator byte");
+      return aerr;
+    }
+    if (aerr == APIError::BAD_HANDSHAKE_PACKET_LEN) {
+      send_explicit_handshake_reject_("Bad handshake packet len");
+      return aerr;
+    }
+    if (aerr != APIError::OK)
+      return aerr;
+    // ignore contents, may be used in future for flags
+    prologue_.push_back((uint8_t)(frame.msg.size() >> 8));
+    prologue_.push_back((uint8_t) frame.msg.size());
+    prologue_.insert(prologue_.end(), frame.msg.begin(), frame.msg.end());
+
+    state_ = State::SERVER_HELLO;
+  }
+  if (state_ == State::SERVER_HELLO) {
+    // send server hello
+    std::vector<uint8_t> msg;
+    // chosen proto
+    msg.push_back(0x01);
+
+    // node name, terminated by null byte
+    const std::string &name = App.get_name();
+    const uint8_t *name_ptr = reinterpret_cast<const uint8_t *>(name.c_str());
+    msg.insert(msg.end(), name_ptr, name_ptr + name.size() + 1);
+
+    aerr = write_frame_(msg.data(), msg.size());
+    if (aerr != APIError::OK)
+      return aerr;
+
+    // start handshake
+    aerr = init_handshake_();
+    if (aerr != APIError::OK)
+      return aerr;
+
+    state_ = State::HANDSHAKE;
+  }
+  if (state_ == State::HANDSHAKE) {
+    int action = noise_handshakestate_get_action(handshake_);
+    if (action == NOISE_ACTION_READ_MESSAGE) {
+      // waiting for handshake msg
+      ParsedFrame frame;
+      aerr = try_read_frame_(&frame);
+      if (aerr == APIError::BAD_INDICATOR) {
+        send_explicit_handshake_reject_("Bad indicator byte");
+        return aerr;
+      }
+      if (aerr == APIError::BAD_HANDSHAKE_PACKET_LEN) {
+        send_explicit_handshake_reject_("Bad handshake packet len");
+        return aerr;
+      }
+      if (aerr != APIError::OK)
+        return aerr;
+
+      if (frame.msg.empty()) {
+        send_explicit_handshake_reject_("Empty handshake message");
+        return APIError::BAD_HANDSHAKE_ERROR_BYTE;
+      } else if (frame.msg[0] != 0x00) {
+        HELPER_LOG("Bad handshake error byte: %u", frame.msg[0]);
+        send_explicit_handshake_reject_("Bad handshake error byte");
+        return APIError::BAD_HANDSHAKE_ERROR_BYTE;
+      }
+
+      NoiseBuffer mbuf;
+      noise_buffer_init(mbuf);
+      noise_buffer_set_input(mbuf, frame.msg.data() + 1, frame.msg.size() - 1);
+      err = noise_handshakestate_read_message(handshake_, &mbuf, nullptr);
+      if (err != 0) {
+        state_ = State::FAILED;
+        HELPER_LOG("noise_handshakestate_read_message failed: %s", noise_err_to_str(err).c_str());
+        if (err == NOISE_ERROR_MAC_FAILURE) {
+          send_explicit_handshake_reject_("Handshake MAC failure");
+        } else {
+          send_explicit_handshake_reject_("Handshake error");
+        }
+        return APIError::HANDSHAKESTATE_READ_FAILED;
+      }
+
+      aerr = check_handshake_finished_();
+      if (aerr != APIError::OK)
+        return aerr;
+    } else if (action == NOISE_ACTION_WRITE_MESSAGE) {
+      uint8_t buffer[65];
+      NoiseBuffer mbuf;
+      noise_buffer_init(mbuf);
+      noise_buffer_set_output(mbuf, buffer + 1, sizeof(buffer) - 1);
+
+      err = noise_handshakestate_write_message(handshake_, &mbuf, nullptr);
+      if (err != 0) {
+        state_ = State::FAILED;
+        HELPER_LOG("noise_handshakestate_write_message failed: %s", noise_err_to_str(err).c_str());
+        return APIError::HANDSHAKESTATE_WRITE_FAILED;
+      }
+      buffer[0] = 0x00;  // success
+
+      aerr = write_frame_(buffer, mbuf.size + 1);
+      if (aerr != APIError::OK)
+        return aerr;
+      aerr = check_handshake_finished_();
+      if (aerr != APIError::OK)
+        return aerr;
+    } else {
+      // bad state for action
+      state_ = State::FAILED;
+      HELPER_LOG("Bad action for handshake: %d", action);
+      return APIError::HANDSHAKESTATE_BAD_STATE;
+    }
+  }
+  if (state_ == State::CLOSED || state_ == State::FAILED) {
+    return APIError::BAD_STATE;
+  }
+  return APIError::OK;
+}
+void APINoiseFrameHelper::send_explicit_handshake_reject_(const std::string &reason) {
+  std::vector<uint8_t> data;
+  data.resize(reason.length() + 1);
+  data[0] = 0x01;  // failure
+  for (size_t i = 0; i < reason.length(); i++) {
+    data[i + 1] = (uint8_t) reason[i];
+  }
+  // temporarily remove failed state
+  auto orig_state = state_;
+  state_ = State::EXPLICIT_REJECT;
+  write_frame_(data.data(), data.size());
+  state_ = orig_state;
+}
+
+APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
+  int err;
+  APIError aerr;
+  aerr = state_action_();
+  if (aerr != APIError::OK) {
+    return aerr;
+  }
+
+  if (state_ != State::DATA) {
+    return APIError::WOULD_BLOCK;
+  }
+
+  ParsedFrame frame;
+  aerr = try_read_frame_(&frame);
+  if (aerr != APIError::OK)
+    return aerr;
+
+  NoiseBuffer mbuf;
+  noise_buffer_init(mbuf);
+  noise_buffer_set_inout(mbuf, frame.msg.data(), frame.msg.size(), frame.msg.size());
+  err = noise_cipherstate_decrypt(recv_cipher_, &mbuf);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_cipherstate_decrypt failed: %s", noise_err_to_str(err).c_str());
+    return APIError::CIPHERSTATE_DECRYPT_FAILED;
+  }
+
+  size_t msg_size = mbuf.size;
+  uint8_t *msg_data = frame.msg.data();
+  if (msg_size < 4) {
+    state_ = State::FAILED;
+    HELPER_LOG("Bad data packet: size %d too short", msg_size);
+    return APIError::BAD_DATA_PACKET;
+  }
+
+  // uint16_t type;
+  // uint16_t data_len;
+  // uint8_t *data;
+  // uint8_t *padding;  zero or more bytes to fill up the rest of the packet
+  uint16_t type = (((uint16_t) msg_data[0]) << 8) | msg_data[1];
+  uint16_t data_len = (((uint16_t) msg_data[2]) << 8) | msg_data[3];
+  if (data_len > msg_size - 4) {
+    state_ = State::FAILED;
+    HELPER_LOG("Bad data packet: data_len %u greater than msg_size %u", data_len, msg_size);
+    return APIError::BAD_DATA_PACKET;
+  }
+
+  buffer->container = std::move(frame.msg);
+  buffer->data_offset = 4;
+  buffer->data_len = data_len;
+  buffer->type = type;
+  return APIError::OK;
+}
+bool APINoiseFrameHelper::can_write_without_blocking() { return state_ == State::DATA && tx_buf_.empty(); }
+APIError APINoiseFrameHelper::write_packet(uint16_t type, const uint8_t *payload, size_t payload_len) {
+  int err;
+  APIError aerr;
+  aerr = state_action_();
+  if (aerr != APIError::OK) {
+    return aerr;
+  }
+
+  if (state_ != State::DATA) {
+    return APIError::WOULD_BLOCK;
+  }
+
+  size_t padding = 0;
+  size_t msg_len = 4 + payload_len + padding;
+  size_t frame_len = 3 + msg_len + noise_cipherstate_get_mac_length(send_cipher_);
+  auto tmpbuf = std::unique_ptr<uint8_t[]>{new (std::nothrow) uint8_t[frame_len]};
+  if (tmpbuf == nullptr) {
+    HELPER_LOG("Could not allocate for writing packet");
+    return APIError::OUT_OF_MEMORY;
+  }
+
+  tmpbuf[0] = 0x01;  // indicator
+  // tmpbuf[1], tmpbuf[2] to be set later
+  const uint8_t msg_offset = 3;
+  const uint8_t payload_offset = msg_offset + 4;
+  tmpbuf[msg_offset + 0] = (uint8_t)(type >> 8);  // type
+  tmpbuf[msg_offset + 1] = (uint8_t) type;
+  tmpbuf[msg_offset + 2] = (uint8_t)(payload_len >> 8);  // data_len
+  tmpbuf[msg_offset + 3] = (uint8_t) payload_len;
+  // copy data
+  std::copy(payload, payload + payload_len, &tmpbuf[payload_offset]);
+  // fill padding with zeros
+  std::fill(&tmpbuf[payload_offset + payload_len], &tmpbuf[frame_len], 0);
+
+  NoiseBuffer mbuf;
+  noise_buffer_init(mbuf);
+  noise_buffer_set_inout(mbuf, &tmpbuf[msg_offset], msg_len, frame_len - msg_offset);
+  err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_cipherstate_encrypt failed: %s", noise_err_to_str(err).c_str());
+    return APIError::CIPHERSTATE_ENCRYPT_FAILED;
+  }
+
+  size_t total_len = 3 + mbuf.size;
+  tmpbuf[1] = (uint8_t)(mbuf.size >> 8);
+  tmpbuf[2] = (uint8_t) mbuf.size;
+
+  struct iovec iov;
+  iov.iov_base = &tmpbuf[0];
+  iov.iov_len = total_len;
+
+  // write raw to not have two packets sent if NAGLE disabled
+  return write_raw_(&iov, 1);
+}
+APIError APINoiseFrameHelper::try_send_tx_buf_() {
+  // try send from tx_buf
+  while (state_ != State::CLOSED && !tx_buf_.empty()) {
+    ssize_t sent = socket_->write(tx_buf_.data(), tx_buf_.size());
+    if (sent == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN)
+        break;
+      state_ = State::FAILED;
+      HELPER_LOG("Socket write failed with errno %d", errno);
+      return APIError::SOCKET_WRITE_FAILED;
+    } else if (sent == 0) {
+      break;
+    }
+    // TODO: inefficient if multiple packets in txbuf
+    // replace with deque of buffers
+    tx_buf_.erase(tx_buf_.begin(), tx_buf_.begin() + sent);
+  }
+
+  return APIError::OK;
+}
+/** Write the data to the socket, or buffer it a write would block
+ *
+ * @param data The data to write
+ * @param len The length of data
+ */
+APIError APINoiseFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
+  if (iovcnt == 0)
+    return APIError::OK;
+  APIError aerr;
+
+  size_t total_write_len = 0;
+  for (int i = 0; i < iovcnt; i++) {
+#ifdef HELPER_LOG_PACKETS
+    ESP_LOGVV(TAG, "Sending raw: %s",
+              format_hex_pretty(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
+#endif
+    total_write_len += iov[i].iov_len;
+  }
+
+  if (!tx_buf_.empty()) {
+    // try to empty tx_buf_ first
+    aerr = try_send_tx_buf_();
+    if (aerr != APIError::OK && aerr != APIError::WOULD_BLOCK)
+      return aerr;
+  }
+
+  if (!tx_buf_.empty()) {
+    // tx buf not empty, can't write now because then stream would be inconsistent
+    for (int i = 0; i < iovcnt; i++) {
+      tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base),
+                     reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+    }
+    return APIError::OK;
+  }
+
+  ssize_t sent = socket_->writev(iov, iovcnt);
+  if (is_would_block(sent)) {
+    // operation would block, add buffer to tx_buf
+    for (int i = 0; i < iovcnt; i++) {
+      tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base),
+                     reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+    }
+    return APIError::OK;
+  } else if (sent == -1) {
+    // an error occured
+    state_ = State::FAILED;
+    HELPER_LOG("Socket write failed with errno %d", errno);
+    return APIError::SOCKET_WRITE_FAILED;
+  } else if ((size_t) sent != total_write_len) {
+    // partially sent, add end to tx_buf
+    size_t to_consume = sent;
+    for (int i = 0; i < iovcnt; i++) {
+      if (to_consume >= iov[i].iov_len) {
+        to_consume -= iov[i].iov_len;
+      } else {
+        tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_consume,
+                       reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+        to_consume = 0;
+      }
+    }
+    return APIError::OK;
+  }
+  // fully sent
+  return APIError::OK;
+}
+APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, size_t len) {
+  uint8_t header[3];
+  header[0] = 0x01;  // indicator
+  header[1] = (uint8_t)(len >> 8);
+  header[2] = (uint8_t) len;
+
+  struct iovec iov[2];
+  iov[0].iov_base = header;
+  iov[0].iov_len = 3;
+  iov[1].iov_base = const_cast<uint8_t *>(data);
+  iov[1].iov_len = len;
+
+  return write_raw_(iov, 2);
+}
+
+/** Initiate the data structures for the handshake.
+ *
+ * @return 0 on success, -1 on error (check errno)
+ */
+APIError APINoiseFrameHelper::init_handshake_() {
+  int err;
+  memset(&nid_, 0, sizeof(nid_));
+  // const char *proto = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
+  // err = noise_protocol_name_to_id(&nid_, proto, strlen(proto));
+  nid_.pattern_id = NOISE_PATTERN_NN;
+  nid_.cipher_id = NOISE_CIPHER_CHACHAPOLY;
+  nid_.dh_id = NOISE_DH_CURVE25519;
+  nid_.prefix_id = NOISE_PREFIX_STANDARD;
+  nid_.hybrid_id = NOISE_DH_NONE;
+  nid_.hash_id = NOISE_HASH_SHA256;
+  nid_.modifier_ids[0] = NOISE_MODIFIER_PSK0;
+
+  err = noise_handshakestate_new_by_id(&handshake_, &nid_, NOISE_ROLE_RESPONDER);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_handshakestate_new_by_id failed: %s", noise_err_to_str(err).c_str());
+    return APIError::HANDSHAKESTATE_SETUP_FAILED;
+  }
+
+  const auto &psk = ctx_->get_psk();
+  err = noise_handshakestate_set_pre_shared_key(handshake_, psk.data(), psk.size());
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_handshakestate_set_pre_shared_key failed: %s", noise_err_to_str(err).c_str());
+    return APIError::HANDSHAKESTATE_SETUP_FAILED;
+  }
+
+  err = noise_handshakestate_set_prologue(handshake_, prologue_.data(), prologue_.size());
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_handshakestate_set_prologue failed: %s", noise_err_to_str(err).c_str());
+    return APIError::HANDSHAKESTATE_SETUP_FAILED;
+  }
+  // set_prologue copies it into handshakestate, so we can get rid of it now
+  prologue_ = {};
+
+  err = noise_handshakestate_start(handshake_);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_handshakestate_start failed: %s", noise_err_to_str(err).c_str());
+    return APIError::HANDSHAKESTATE_SETUP_FAILED;
+  }
+  return APIError::OK;
+}
+
+APIError APINoiseFrameHelper::check_handshake_finished_() {
+  assert(state_ == State::HANDSHAKE);
+
+  int action = noise_handshakestate_get_action(handshake_);
+  if (action == NOISE_ACTION_READ_MESSAGE || action == NOISE_ACTION_WRITE_MESSAGE)
+    return APIError::OK;
+  if (action != NOISE_ACTION_SPLIT) {
+    state_ = State::FAILED;
+    HELPER_LOG("Bad action for handshake: %d", action);
+    return APIError::HANDSHAKESTATE_BAD_STATE;
+  }
+  int err = noise_handshakestate_split(handshake_, &send_cipher_, &recv_cipher_);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("noise_handshakestate_split failed: %s", noise_err_to_str(err).c_str());
+    return APIError::HANDSHAKESTATE_SPLIT_FAILED;
+  }
+
+  HELPER_LOG("Handshake complete!");
+  noise_handshakestate_free(handshake_);
+  handshake_ = nullptr;
+  state_ = State::DATA;
+  return APIError::OK;
+}
+
+APINoiseFrameHelper::~APINoiseFrameHelper() {
+  if (handshake_ != nullptr) {
+    noise_handshakestate_free(handshake_);
+    handshake_ = nullptr;
+  }
+  if (send_cipher_ != nullptr) {
+    noise_cipherstate_free(send_cipher_);
+    send_cipher_ = nullptr;
+  }
+  if (recv_cipher_ != nullptr) {
+    noise_cipherstate_free(recv_cipher_);
+    recv_cipher_ = nullptr;
+  }
+}
+
+APIError APINoiseFrameHelper::close() {
+  state_ = State::CLOSED;
+  int err = socket_->close();
+  if (err == -1)
+    return APIError::CLOSE_FAILED;
+  return APIError::OK;
+}
+APIError APINoiseFrameHelper::shutdown(int how) {
+  int err = socket_->shutdown(how);
+  if (err == -1)
+    return APIError::SHUTDOWN_FAILED;
+  if (how == SHUT_RDWR) {
+    state_ = State::CLOSED;
+  }
+  return APIError::OK;
+}
+extern "C" {
+// declare how noise generates random bytes (here with a good HWRNG based on the RF system)
+void noise_rand_bytes(void *output, size_t len) {
+  if (!esphome::random_bytes(reinterpret_cast<uint8_t *>(output), len)) {
+    ESP_LOGE(TAG, "Failed to acquire random bytes, rebooting!");
+    arch_restart();
+  }
+}
+}
+#endif  // USE_API_NOISE
+
+#ifdef USE_API_PLAINTEXT
+
+/// Initialize the frame helper, returns OK if successful.
+APIError APIPlaintextFrameHelper::init() {
+  if (state_ != State::INITIALIZE || socket_ == nullptr) {
+    HELPER_LOG("Bad state for init %d", (int) state_);
+    return APIError::BAD_STATE;
+  }
+  int err = socket_->setblocking(false);
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("Setting nonblocking failed with errno %d", errno);
+    return APIError::TCP_NONBLOCKING_FAILED;
+  }
+  int enable = 1;
+  err = socket_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(int));
+  if (err != 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("Setting nodelay failed with errno %d", errno);
+    return APIError::TCP_NODELAY_FAILED;
+  }
+
+  state_ = State::DATA;
+  return APIError::OK;
+}
+/// Not used for plaintext
+APIError APIPlaintextFrameHelper::loop() {
+  if (state_ != State::DATA) {
+    return APIError::BAD_STATE;
+  }
+  // try send pending TX data
+  if (!tx_buf_.empty()) {
+    APIError err = try_send_tx_buf_();
+    if (err != APIError::OK) {
+      return err;
+    }
+  }
+  return APIError::OK;
+}
+
+/** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
+ *
+ * @param frame: The struct to hold the frame information in.
+ *   msg: store the parsed frame in that struct
+ *
+ * @return See APIError
+ *
+ * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
+ */
+APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
+  if (frame == nullptr) {
+    HELPER_LOG("Bad argument for try_read_frame_");
+    return APIError::BAD_ARG;
+  }
+
+  // read header
+  while (!rx_header_parsed_) {
+    uint8_t data;
+    ssize_t received = socket_->read(&data, 1);
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
+    }
+    rx_header_buf_.push_back(data);
+
+    // try parse header
+    if (rx_header_buf_[0] != 0x00) {
+      state_ = State::FAILED;
+      HELPER_LOG("Bad indicator byte %u", rx_header_buf_[0]);
+      return APIError::BAD_INDICATOR;
+    }
+
+    size_t i = 1;
+    uint32_t consumed = 0;
+    auto msg_size_varint = ProtoVarInt::parse(&rx_header_buf_[i], rx_header_buf_.size() - i, &consumed);
+    if (!msg_size_varint.has_value()) {
+      // not enough data there yet
+      continue;
+    }
+
+    i += consumed;
+    rx_header_parsed_len_ = msg_size_varint->as_uint32();
+
+    auto msg_type_varint = ProtoVarInt::parse(&rx_header_buf_[i], rx_header_buf_.size() - i, &consumed);
+    if (!msg_type_varint.has_value()) {
+      // not enough data there yet
+      continue;
+    }
+    rx_header_parsed_type_ = msg_type_varint->as_uint32();
+    rx_header_parsed_ = true;
+  }
+  // header reading done
+
+  // reserve space for body
+  if (rx_buf_.size() != rx_header_parsed_len_) {
+    rx_buf_.resize(rx_header_parsed_len_);
+  }
+
+  if (rx_buf_len_ < rx_header_parsed_len_) {
+    // more data to read
+    size_t to_read = rx_header_parsed_len_ - rx_buf_len_;
+    ssize_t received = socket_->read(&rx_buf_[rx_buf_len_], to_read);
+    if (received == -1) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+        return APIError::WOULD_BLOCK;
+      }
+      state_ = State::FAILED;
+      HELPER_LOG("Socket read failed with errno %d", errno);
+      return APIError::SOCKET_READ_FAILED;
+    } else if (received == 0) {
+      state_ = State::FAILED;
+      HELPER_LOG("Connection closed");
+      return APIError::CONNECTION_CLOSED;
+    }
+    rx_buf_len_ += received;
+    if ((size_t) received != to_read) {
+      // not all read
+      return APIError::WOULD_BLOCK;
+    }
+  }
+
+  // uncomment for even more debugging
+#ifdef HELPER_LOG_PACKETS
+  ESP_LOGVV(TAG, "Received frame: %s", format_hex_pretty(rx_buf_).c_str());
+#endif
+  frame->msg = std::move(rx_buf_);
+  // consume msg
+  rx_buf_ = {};
+  rx_buf_len_ = 0;
+  rx_header_buf_.clear();
+  rx_header_parsed_ = false;
+  return APIError::OK;
+}
+
+APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
+  APIError aerr;
+
+  if (state_ != State::DATA) {
+    return APIError::WOULD_BLOCK;
+  }
+
+  ParsedFrame frame;
+  aerr = try_read_frame_(&frame);
+  if (aerr != APIError::OK)
+    return aerr;
+
+  buffer->container = std::move(frame.msg);
+  buffer->data_offset = 0;
+  buffer->data_len = rx_header_parsed_len_;
+  buffer->type = rx_header_parsed_type_;
+  return APIError::OK;
+}
+bool APIPlaintextFrameHelper::can_write_without_blocking() { return state_ == State::DATA && tx_buf_.empty(); }
+APIError APIPlaintextFrameHelper::write_packet(uint16_t type, const uint8_t *payload, size_t payload_len) {
+  if (state_ != State::DATA) {
+    return APIError::BAD_STATE;
+  }
+
+  std::vector<uint8_t> header;
+  header.push_back(0x00);
+  ProtoVarInt(payload_len).encode(header);
+  ProtoVarInt(type).encode(header);
+
+  struct iovec iov[2];
+  iov[0].iov_base = &header[0];
+  iov[0].iov_len = header.size();
+  iov[1].iov_base = const_cast<uint8_t *>(payload);
+  iov[1].iov_len = payload_len;
+
+  return write_raw_(iov, 2);
+}
+APIError APIPlaintextFrameHelper::try_send_tx_buf_() {
+  // try send from tx_buf
+  while (state_ != State::CLOSED && !tx_buf_.empty()) {
+    ssize_t sent = socket_->write(tx_buf_.data(), tx_buf_.size());
+    if (is_would_block(sent)) {
+      break;
+    } else if (sent == -1) {
+      state_ = State::FAILED;
+      HELPER_LOG("Socket write failed with errno %d", errno);
+      return APIError::SOCKET_WRITE_FAILED;
+    }
+    // TODO: inefficient if multiple packets in txbuf
+    // replace with deque of buffers
+    tx_buf_.erase(tx_buf_.begin(), tx_buf_.begin() + sent);
+  }
+
+  return APIError::OK;
+}
+/** Write the data to the socket, or buffer it a write would block
+ *
+ * @param data The data to write
+ * @param len The length of data
+ */
+APIError APIPlaintextFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
+  if (iovcnt == 0)
+    return APIError::OK;
+  APIError aerr;
+
+  size_t total_write_len = 0;
+  for (int i = 0; i < iovcnt; i++) {
+#ifdef HELPER_LOG_PACKETS
+    ESP_LOGVV(TAG, "Sending raw: %s",
+              format_hex_pretty(reinterpret_cast<uint8_t *>(iov[i].iov_base), iov[i].iov_len).c_str());
+#endif
+    total_write_len += iov[i].iov_len;
+  }
+
+  if (!tx_buf_.empty()) {
+    // try to empty tx_buf_ first
+    aerr = try_send_tx_buf_();
+    if (aerr != APIError::OK && aerr != APIError::WOULD_BLOCK)
+      return aerr;
+  }
+
+  if (!tx_buf_.empty()) {
+    // tx buf not empty, can't write now because then stream would be inconsistent
+    for (int i = 0; i < iovcnt; i++) {
+      tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base),
+                     reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+    }
+    return APIError::OK;
+  }
+
+  ssize_t sent = socket_->writev(iov, iovcnt);
+  if (is_would_block(sent)) {
+    // operation would block, add buffer to tx_buf
+    for (int i = 0; i < iovcnt; i++) {
+      tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base),
+                     reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+    }
+    return APIError::OK;
+  } else if (sent == -1) {
+    // an error occured
+    state_ = State::FAILED;
+    HELPER_LOG("Socket write failed with errno %d", errno);
+    return APIError::SOCKET_WRITE_FAILED;
+  } else if ((size_t) sent != total_write_len) {
+    // partially sent, add end to tx_buf
+    size_t to_consume = sent;
+    for (int i = 0; i < iovcnt; i++) {
+      if (to_consume >= iov[i].iov_len) {
+        to_consume -= iov[i].iov_len;
+      } else {
+        tx_buf_.insert(tx_buf_.end(), reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_consume,
+                       reinterpret_cast<uint8_t *>(iov[i].iov_base) + iov[i].iov_len);
+        to_consume = 0;
+      }
+    }
+    return APIError::OK;
+  }
+  // fully sent
+  return APIError::OK;
+}
+
+APIError APIPlaintextFrameHelper::close() {
+  state_ = State::CLOSED;
+  int err = socket_->close();
+  if (err == -1)
+    return APIError::CLOSE_FAILED;
+  return APIError::OK;
+}
+APIError APIPlaintextFrameHelper::shutdown(int how) {
+  int err = socket_->shutdown(how);
+  if (err == -1)
+    return APIError::SHUTDOWN_FAILED;
+  if (how == SHUT_RDWR) {
+    state_ = State::CLOSED;
+  }
+  return APIError::OK;
+}
+#endif  // USE_API_PLAINTEXT
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_frame_helper.h

@@ -0,0 +1,185 @@
+#pragma once
+#include <cstdint>
+#include <deque>
+#include <utility>
+#include <vector>
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_API_NOISE
+#include "noise/protocol.h"
+#endif
+
+#include "esphome/components/socket/socket.h"
+#include "api_noise_context.h"
+
+namespace esphome {
+namespace api {
+
+struct ReadPacketBuffer {
+  std::vector<uint8_t> container;
+  uint16_t type;
+  size_t data_offset;
+  size_t data_len;
+};
+
+struct PacketBuffer {
+  const std::vector<uint8_t> container;
+  uint16_t type;
+  uint8_t data_offset;
+  uint8_t data_len;
+};
+
+enum class APIError : int {
+  OK = 0,
+  WOULD_BLOCK = 1001,
+  BAD_HANDSHAKE_PACKET_LEN = 1002,
+  BAD_INDICATOR = 1003,
+  BAD_DATA_PACKET = 1004,
+  TCP_NODELAY_FAILED = 1005,
+  TCP_NONBLOCKING_FAILED = 1006,
+  CLOSE_FAILED = 1007,
+  SHUTDOWN_FAILED = 1008,
+  BAD_STATE = 1009,
+  BAD_ARG = 1010,
+  SOCKET_READ_FAILED = 1011,
+  SOCKET_WRITE_FAILED = 1012,
+  HANDSHAKESTATE_READ_FAILED = 1013,
+  HANDSHAKESTATE_WRITE_FAILED = 1014,
+  HANDSHAKESTATE_BAD_STATE = 1015,
+  CIPHERSTATE_DECRYPT_FAILED = 1016,
+  CIPHERSTATE_ENCRYPT_FAILED = 1017,
+  OUT_OF_MEMORY = 1018,
+  HANDSHAKESTATE_SETUP_FAILED = 1019,
+  HANDSHAKESTATE_SPLIT_FAILED = 1020,
+  BAD_HANDSHAKE_ERROR_BYTE = 1021,
+  CONNECTION_CLOSED = 1022,
+};
+
+const char *api_error_to_str(APIError err);
+
+class APIFrameHelper {
+ public:
+  virtual ~APIFrameHelper() = default;
+  virtual APIError init() = 0;
+  virtual APIError loop() = 0;
+  virtual APIError read_packet(ReadPacketBuffer *buffer) = 0;
+  virtual bool can_write_without_blocking() = 0;
+  virtual APIError write_packet(uint16_t type, const uint8_t *data, size_t len) = 0;
+  virtual std::string getpeername() = 0;
+  virtual APIError close() = 0;
+  virtual APIError shutdown(int how) = 0;
+  // Give this helper a name for logging
+  virtual void set_log_info(std::string info) = 0;
+};
+
+#ifdef USE_API_NOISE
+class APINoiseFrameHelper : public APIFrameHelper {
+ public:
+  APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, std::shared_ptr<APINoiseContext> ctx)
+      : socket_(std::move(socket)), ctx_(std::move(std::move(ctx))) {}
+  ~APINoiseFrameHelper() override;
+  APIError init() override;
+  APIError loop() override;
+  APIError read_packet(ReadPacketBuffer *buffer) override;
+  bool can_write_without_blocking() override;
+  APIError write_packet(uint16_t type, const uint8_t *payload, size_t len) override;
+  std::string getpeername() override { return socket_->getpeername(); }
+  APIError close() override;
+  APIError shutdown(int how) override;
+  // Give this helper a name for logging
+  void set_log_info(std::string info) override { info_ = std::move(info); }
+
+ protected:
+  struct ParsedFrame {
+    std::vector<uint8_t> msg;
+  };
+
+  APIError state_action_();
+  APIError try_read_frame_(ParsedFrame *frame);
+  APIError try_send_tx_buf_();
+  APIError write_frame_(const uint8_t *data, size_t len);
+  APIError write_raw_(const struct iovec *iov, int iovcnt);
+  APIError init_handshake_();
+  APIError check_handshake_finished_();
+  void send_explicit_handshake_reject_(const std::string &reason);
+
+  std::unique_ptr<socket::Socket> socket_;
+
+  std::string info_;
+  uint8_t rx_header_buf_[3];
+  size_t rx_header_buf_len_ = 0;
+  std::vector<uint8_t> rx_buf_;
+  size_t rx_buf_len_ = 0;
+
+  std::vector<uint8_t> tx_buf_;
+  std::vector<uint8_t> prologue_;
+
+  std::shared_ptr<APINoiseContext> ctx_;
+  NoiseHandshakeState *handshake_ = nullptr;
+  NoiseCipherState *send_cipher_ = nullptr;
+  NoiseCipherState *recv_cipher_ = nullptr;
+  NoiseProtocolId nid_;
+
+  enum class State {
+    INITIALIZE = 1,
+    CLIENT_HELLO = 2,
+    SERVER_HELLO = 3,
+    HANDSHAKE = 4,
+    DATA = 5,
+    CLOSED = 6,
+    FAILED = 7,
+    EXPLICIT_REJECT = 8,
+  } state_ = State::INITIALIZE;
+};
+#endif  // USE_API_NOISE
+
+#ifdef USE_API_PLAINTEXT
+class APIPlaintextFrameHelper : public APIFrameHelper {
+ public:
+  APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : socket_(std::move(socket)) {}
+  ~APIPlaintextFrameHelper() override = default;
+  APIError init() override;
+  APIError loop() override;
+  APIError read_packet(ReadPacketBuffer *buffer) override;
+  bool can_write_without_blocking() override;
+  APIError write_packet(uint16_t type, const uint8_t *payload, size_t len) override;
+  std::string getpeername() override { return socket_->getpeername(); }
+  APIError close() override;
+  APIError shutdown(int how) override;
+  // Give this helper a name for logging
+  void set_log_info(std::string info) override { info_ = std::move(info); }
+
+ protected:
+  struct ParsedFrame {
+    std::vector<uint8_t> msg;
+  };
+
+  APIError try_read_frame_(ParsedFrame *frame);
+  APIError try_send_tx_buf_();
+  APIError write_raw_(const struct iovec *iov, int iovcnt);
+
+  std::unique_ptr<socket::Socket> socket_;
+
+  std::string info_;
+  std::vector<uint8_t> rx_header_buf_;
+  bool rx_header_parsed_ = false;
+  uint32_t rx_header_parsed_type_ = 0;
+  uint32_t rx_header_parsed_len_ = 0;
+
+  std::vector<uint8_t> rx_buf_;
+  size_t rx_buf_len_ = 0;
+
+  std::vector<uint8_t> tx_buf_;
+
+  enum class State {
+    INITIALIZE = 1,
+    DATA = 2,
+    CLOSED = 3,
+    FAILED = 4,
+  } state_ = State::INITIALIZE;
+};
+#endif
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_noise_context.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <cstdint>
+#include <array>
+#include "esphome/core/defines.h"
+
+namespace esphome {
+namespace api {
+
+#ifdef USE_API_NOISE
+using psk_t = std::array<uint8_t, 32>;
+
+class APINoiseContext {
+ public:
+  void set_psk(psk_t psk) { psk_ = psk; }
+  const psk_t &get_psk() const { return psk_; }
+
+ protected:
+  psk_t psk_;
+};
+#endif  // USE_API_NOISE
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_pb2.h

@@ -9,6 +9,11 @@ namespace api {
 
 namespace enums {
 
+enum EntityCategory : uint32_t {
+  ENTITY_CATEGORY_NONE = 0,
+  ENTITY_CATEGORY_CONFIG = 1,
+  ENTITY_CATEGORY_DIAGNOSTIC = 2,
+};
 enum LegacyCoverState : uint32_t {
   LEGACY_COVER_STATE_OPEN = 0,
   LEGACY_COVER_STATE_CLOSED = 1,
@@ -32,14 +37,37 @@ 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,
+  STATE_CLASS_TOTAL_INCREASING = 2,
+};
+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 +81,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 +103,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 +113,71 @@ 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,
+};
+enum NumberMode : uint32_t {
+  NUMBER_MODE_AUTO = 0,
+  NUMBER_MODE_BOX = 1,
+  NUMBER_MODE_SLIDER = 2,
+};
+enum LockState : uint32_t {
+  LOCK_STATE_NONE = 0,
+  LOCK_STATE_LOCKED = 1,
+  LOCK_STATE_UNLOCKED = 2,
+  LOCK_STATE_JAMMED = 3,
+  LOCK_STATE_LOCKING = 4,
+  LOCK_STATE_UNLOCKING = 5,
+};
+enum LockCommand : uint32_t {
+  LOCK_UNLOCK = 0,
+  LOCK_LOCK = 1,
+  LOCK_OPEN = 2,
+};
+enum MediaPlayerState : uint32_t {
+  MEDIA_PLAYER_STATE_NONE = 0,
+  MEDIA_PLAYER_STATE_IDLE = 1,
+  MEDIA_PLAYER_STATE_PLAYING = 2,
+  MEDIA_PLAYER_STATE_PAUSED = 3,
+};
+enum MediaPlayerCommand : uint32_t {
+  MEDIA_PLAYER_COMMAND_PLAY = 0,
+  MEDIA_PLAYER_COMMAND_PAUSE = 1,
+  MEDIA_PLAYER_COMMAND_STOP = 2,
+  MEDIA_PLAYER_COMMAND_MUTE = 3,
+  MEDIA_PLAYER_COMMAND_UNMUTE = 4,
+};
 
 }  // 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{};
+  std::string name{};
   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 +185,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 +208,64 @@ 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{};
+  uint32_t webserver_port{0};
   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 +274,45 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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 +321,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 +335,21 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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 +358,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 +374,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 +393,21 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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 +416,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 +433,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 +455,25 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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 +482,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 +507,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 +546,23 @@ 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 legacy_last_reset_type{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
   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 +571,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 +585,19 @@ 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};
+  enums::EntityCategory entity_category{};
+  std::string device_class{};
   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 +606,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 +619,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 +632,32 @@ 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};
+  enums::EntityCategory entity_category{};
   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 +666,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 +693,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 +730,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 +764,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 +796,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 +810,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 +831,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 +844,32 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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 +878,42 @@ 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};
+  std::string icon{};
+  enums::EntityCategory entity_category{};
   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,45 +922,295 @@ 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};
+  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};
+  enums::EntityCategory entity_category{};
+  std::string unit_of_measurement{};
+  enums::NumberMode mode{};
+  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 ClimateCommandRequest : public ProtoMessage {
+class NumberCommandRequest : 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};
+  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};
+  enums::EntityCategory entity_category{};
+  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;
+};
+class ListEntitiesLockResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  bool assumed_state{false};
+  bool supports_open{false};
+  bool requires_code{false};
+  std::string code_format{};
+  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 LockStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::LockState 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_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class LockCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::LockCommand command{};
+  bool has_code{false};
+  std::string code{};
+  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 ListEntitiesButtonResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  std::string device_class{};
+  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 ButtonCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{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 ListEntitiesMediaPlayerResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  bool supports_pause{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 MediaPlayerStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  enums::MediaPlayerState state{};
+  float volume{0.0f};
+  bool muted{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 MediaPlayerCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_command{false};
+  enums::MediaPlayerCommand command{};
+  bool has_volume{false};
+  float volume{0.0f};
+  bool has_media_url{false};
+  std::string media_url{};
+  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;
 };
 

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,193 @@ 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
+#ifdef USE_LOCK
+bool APIServerConnectionBase::send_list_entities_lock_response(const ListEntitiesLockResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_lock_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesLockResponse>(msg, 58);
+}
+#endif
+#ifdef USE_LOCK
+bool APIServerConnectionBase::send_lock_state_response(const LockStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_lock_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<LockStateResponse>(msg, 59);
+}
+#endif
+#ifdef USE_LOCK
+#endif
+#ifdef USE_BUTTON
+bool APIServerConnectionBase::send_list_entities_button_response(const ListEntitiesButtonResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_button_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesButtonResponse>(msg, 61);
+}
+#endif
+#ifdef USE_BUTTON
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_media_player_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesMediaPlayerResponse>(msg, 63);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool APIServerConnectionBase::send_media_player_state_response(const MediaPlayerStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_media_player_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<MediaPlayerStateResponse>(msg, 64);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+#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 +424,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 +435,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 +446,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 +457,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 +467,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 +522,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 +533,65 @@ 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;
+    }
+    case 60: {
+#ifdef USE_LOCK
+      LockCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_lock_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_lock_command_request(msg);
+#endif
+      break;
+    }
+    case 62: {
+#ifdef USE_BUTTON
+      ButtonCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_button_command_request(msg);
+#endif
+      break;
+    }
+    case 65: {
+#ifdef USE_MEDIA_PLAYER
+      MediaPlayerCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_media_player_command_request(msg);
 #endif
       break;
     }
@@ -547,6 +790,71 @@ 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
+#ifdef USE_BUTTON
+void APIServerConnection::on_button_command_request(const ButtonCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->button_command(msg);
+}
+#endif
+#ifdef USE_LOCK
+void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->lock_command(msg);
+}
+#endif
+#ifdef USE_MEDIA_PLAYER
+void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->media_player_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -111,6 +111,48 @@ 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
+#ifdef USE_LOCK
+  bool send_list_entities_lock_response(const ListEntitiesLockResponse &msg);
+#endif
+#ifdef USE_LOCK
+  bool send_lock_state_response(const LockStateResponse &msg);
+#endif
+#ifdef USE_LOCK
+  virtual void on_lock_command_request(const LockCommandRequest &value){};
+#endif
+#ifdef USE_BUTTON
+  bool send_list_entities_button_response(const ListEntitiesButtonResponse &msg);
+#endif
+#ifdef USE_BUTTON
+  virtual void on_button_command_request(const ButtonCommandRequest &value){};
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_list_entities_media_player_response(const ListEntitiesMediaPlayerResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool send_media_player_state_response(const MediaPlayerStateResponse &msg);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -147,6 +189,21 @@ 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
+#ifdef USE_BUTTON
+  virtual void button_command(const ButtonCommandRequest &msg) = 0;
+#endif
+#ifdef USE_LOCK
+  virtual void lock_command(const LockCommandRequest &msg) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -179,6 +236,21 @@ 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
+#ifdef USE_BUTTON
+  void on_button_command_request(const ButtonCommandRequest &msg) override;
+#endif
+#ifdef USE_LOCK
+  void on_lock_command_request(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api

esphome/components/api/api_server.cpp

@@ -1,10 +1,13 @@
 #include "api_server.h"
 #include "api_connection.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
-#include "esphome/core/util.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+#include "esphome/core/util.h"
 #include "esphome/core/version.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/network/util.h"
+#include <cerrno>
 
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
@@ -15,30 +18,58 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api";
+static const char *const TAG = "api";
 
 // APIServer
 void APIServer::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Home Assistant API server...");
   this->setup_controller();
-  this->server_ = AsyncServer(this->port_);
-  this->server_.setNoDelay(false);
-  this->server_.begin();
-  this->server_.onClient(
-      [](void *s, AsyncClient *client) {
-        if (client == nullptr)
-          return;
+  socket_ = socket::socket_ip(SOCK_STREAM, 0);
+  if (socket_ == nullptr) {
+    ESP_LOGW(TAG, "Could not create socket.");
+    this->mark_failed();
+    return;
+  }
+  int enable = 1;
+  int err = socket_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
+  if (err != 0) {
+    ESP_LOGW(TAG, "Socket unable to set reuseaddr: errno %d", err);
+    // we can still continue
+  }
+  err = socket_->setblocking(false);
+  if (err != 0) {
+    ESP_LOGW(TAG, "Socket unable to set nonblocking mode: errno %d", err);
+    this->mark_failed();
+    return;
+  }
+
+  struct sockaddr_storage server;
+
+  socklen_t sl = socket::set_sockaddr_any((struct sockaddr *) &server, sizeof(server), htons(this->port_));
+  if (sl == 0) {
+    ESP_LOGW(TAG, "Socket unable to set sockaddr: errno %d", errno);
+    this->mark_failed();
+    return;
+  }
+
+  err = socket_->bind((struct sockaddr *) &server, sl);
+  if (err != 0) {
+    ESP_LOGW(TAG, "Socket unable to bind: errno %d", errno);
+    this->mark_failed();
+    return;
+  }
+
+  err = socket_->listen(4);
+  if (err != 0) {
+    ESP_LOGW(TAG, "Socket unable to listen: errno %d", errno);
+    this->mark_failed();
+    return;
+  }
 
-        // can't print here because in lwIP thread
-        // ESP_LOGD(TAG, "New client connected from %s", client->remoteIP().toString().c_str());
-        auto *a_this = (APIServer *) s;
-        a_this->clients_.push_back(new APIConnection(client, a_this));
-      },
-      this);
 #ifdef USE_LOGGER
   if (logger::global_logger != nullptr) {
     logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
-      for (auto *c : this->clients_) {
+      for (auto &c : this->clients_) {
         if (!c->remove_)
           c->send_log_message(level, tag, message);
       }
@@ -49,31 +80,43 @@ void APIServer::setup() {
   this->last_connected_ = millis();
 
 #ifdef USE_ESP32_CAMERA
-  if (esp32_camera::global_esp32_camera != nullptr) {
-    esp32_camera::global_esp32_camera->add_image_callback([this](std::shared_ptr<esp32_camera::CameraImage> image) {
-      for (auto *c : this->clients_)
-        if (!c->remove_)
-          c->send_camera_state(image);
-    });
+  if (esp32_camera::global_esp32_camera != nullptr && !esp32_camera::global_esp32_camera->is_internal()) {
+    esp32_camera::global_esp32_camera->add_image_callback(
+        [this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
+          for (auto &c : this->clients_) {
+            if (!c->remove_)
+              c->send_camera_state(image);
+          }
+        });
   }
 #endif
 }
 void APIServer::loop() {
+  // Accept new clients
+  while (true) {
+    struct sockaddr_storage source_addr;
+    socklen_t addr_len = sizeof(source_addr);
+    auto sock = socket_->accept((struct sockaddr *) &source_addr, &addr_len);
+    if (!sock)
+      break;
+    ESP_LOGD(TAG, "Accepted %s", sock->getpeername().c_str());
+
+    auto *conn = new APIConnection(std::move(sock), this);
+    clients_.emplace_back(conn);
+    conn->start();
+  }
+
   // Partition clients into remove and active
-  auto new_end =
-      std::partition(this->clients_.begin(), this->clients_.end(), [](APIConnection *conn) { return !conn->remove_; });
+  auto new_end = std::partition(this->clients_.begin(), this->clients_.end(),
+                                [](const std::unique_ptr<APIConnection> &conn) { return !conn->remove_; });
   // print disconnection messages
   for (auto it = new_end; it != this->clients_.end(); ++it) {
-    ESP_LOGD(TAG, "Disconnecting %s", (*it)->client_info_.c_str());
+    ESP_LOGV(TAG, "Removing connection to %s", (*it)->client_info_.c_str());
   }
-  // only then delete the pointers, otherwise log routine
-  // would access freed memory
-  for (auto it = new_end; it != this->clients_.end(); ++it)
-    delete *it;
   // resize vector
   this->clients_.erase(new_end, this->clients_.end());
 
-  for (auto *client : this->clients_) {
+  for (auto &client : this->clients_) {
     client->loop();
   }
 
@@ -93,7 +136,12 @@ void APIServer::loop() {
 }
 void APIServer::dump_config() {
   ESP_LOGCONFIG(TAG, "API Server:");
-  ESP_LOGCONFIG(TAG, "  Address: %s:%u", network_get_address().c_str(), this->port_);
+  ESP_LOGCONFIG(TAG, "  Address: %s:%u", network::get_use_address().c_str(), this->port_);
+#ifdef USE_API_NOISE
+  ESP_LOGCONFIG(TAG, "  Using noise encryption: YES");
+#else
+  ESP_LOGCONFIG(TAG, "  Using noise encryption: NO");
+#endif
 }
 bool APIServer::uses_password() const { return !this->password_.empty(); }
 bool APIServer::check_password(const std::string &password) const {
@@ -129,7 +177,7 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
 void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_binary_sensor_state(obj, state);
 }
 #endif
@@ -138,16 +186,16 @@ void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool s
 void APIServer::on_cover_update(cover::Cover *obj) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_cover_state(obj);
 }
 #endif
 
 #ifdef USE_FAN
-void APIServer::on_fan_update(fan::FanState *obj) {
+void APIServer::on_fan_update(fan::Fan *obj) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_fan_state(obj);
 }
 #endif
@@ -156,7 +204,7 @@ void APIServer::on_fan_update(fan::FanState *obj) {
 void APIServer::on_light_update(light::LightState *obj) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_light_state(obj);
 }
 #endif
@@ -165,7 +213,7 @@ void APIServer::on_light_update(light::LightState *obj) {
 void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_sensor_state(obj, state);
 }
 #endif
@@ -174,16 +222,16 @@ void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
 void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_switch_state(obj, 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_)
+  for (auto &c : this->clients_)
     c->send_text_sensor_state(obj, state);
 }
 #endif
@@ -192,25 +240,63 @@ void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, std::string
 void APIServer::on_climate_update(climate::Climate *obj) {
   if (obj->is_internal())
     return;
-  for (auto *c : this->clients_)
+  for (auto &c : this->clients_)
     c->send_climate_state(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, size_t index) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_select_state(obj, state);
+}
+#endif
+
+#ifdef USE_LOCK
+void APIServer::on_lock_update(lock::Lock *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_lock_state(obj, obj->state);
+}
+#endif
+
+#ifdef USE_MEDIA_PLAYER
+void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_media_player_state(obj);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
-APIServer *global_api_server = nullptr;
+APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void APIServer::set_password(const std::string &password) { this->password_ = password; }
 void APIServer::send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
-  for (auto *client : this->clients_) {
+  for (auto &client : this->clients_) {
     client->send_homeassistant_service_call(call);
   }
 }
 APIServer::APIServer() { global_api_server = this; }
-void APIServer::subscribe_home_assistant_state(std::string entity_id, 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),
   });
 }
@@ -221,7 +307,7 @@ uint16_t APIServer::get_port() const { return this->port_; }
 void APIServer::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
-  for (auto *client : this->clients_) {
+  for (auto &client : this->clients_) {
     if (!client->remove_ && client->connection_state_ == APIConnection::ConnectionState::CONNECTED)
       client->send_time_request();
   }
@@ -229,7 +315,7 @@ void APIServer::request_time() {
 #endif
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
 void APIServer::on_shutdown() {
-  for (auto *c : this->clients_) {
+  for (auto &c : this->clients_) {
     c->send_disconnect_request(DisconnectRequest());
   }
   delay(10);

esphome/components/api/api_server.h

@@ -4,20 +4,13 @@
 #include "esphome/core/controller.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/log.h"
+#include "esphome/components/socket/socket.h"
 #include "api_pb2.h"
 #include "api_pb2_service.h"
-#include "util.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
-#include "homeassistant_service.h"
 #include "user_services.h"
-
-#ifdef ARDUINO_ARCH_ESP32
-#include <AsyncTCP.h>
-#endif
-#ifdef ARDUINO_ARCH_ESP8266
-#include <ESPAsyncTCP.h>
-#endif
+#include "api_noise_context.h"
 
 namespace esphome {
 namespace api {
@@ -36,6 +29,12 @@ class APIServer : public Component, public Controller {
   void set_port(uint16_t port);
   void set_password(const std::string &password);
   void set_reboot_timeout(uint32_t reboot_timeout);
+
+#ifdef USE_API_NOISE
+  void set_noise_psk(psk_t psk) { noise_ctx_->set_psk(psk); }
+  std::shared_ptr<APINoiseContext> get_noise_ctx() { return noise_ctx_; }
+#endif  // USE_API_NOISE
+
   void handle_disconnect(APIConnection *conn);
 #ifdef USE_BINARY_SENSOR
   void on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) override;
@@ -44,7 +43,7 @@ class APIServer : public Component, public Controller {
   void on_cover_update(cover::Cover *obj) override;
 #endif
 #ifdef USE_FAN
-  void on_fan_update(fan::FanState *obj) override;
+  void on_fan_update(fan::Fan *obj) override;
 #endif
 #ifdef USE_LIGHT
   void on_light_update(light::LightState *obj) override;
@@ -56,10 +55,22 @@ 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, size_t index) override;
+#endif
+#ifdef USE_LOCK
+  void on_lock_update(lock::Lock *obj) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
@@ -71,25 +82,31 @@ 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_; }
 
  protected:
-  AsyncServer server_{0};
+  std::unique_ptr<socket::Socket> socket_ = nullptr;
   uint16_t port_{6053};
   uint32_t reboot_timeout_{300000};
   uint32_t last_connected_{0};
-  std::vector<APIConnection *> clients_;
+  std::vector<std::unique_ptr<APIConnection>> clients_;
   std::string password_;
   std::vector<HomeAssistantStateSubscription> state_subs_;
   std::vector<UserServiceDescriptor *> user_services_;
+
+#ifdef USE_API_NOISE
+  std::shared_ptr<APINoiseContext> noise_ctx_ = std::make_shared<APINoiseContext>();
+#endif  // USE_API_NOISE
 };
 
-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/client.py

@@ -0,0 +1,71 @@
+import asyncio
+import logging
+from datetime import datetime
+from typing import Optional
+
+from aioesphomeapi import APIClient, ReconnectLogic, APIConnectionError, LogLevel
+import zeroconf
+
+from esphome.const import CONF_KEY, CONF_PORT, CONF_PASSWORD, __version__
+from esphome.util import safe_print
+from . import CONF_ENCRYPTION
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_run_logs(config, address):
+    conf = config["api"]
+    port: int = int(conf[CONF_PORT])
+    password: str = conf[CONF_PASSWORD]
+    noise_psk: Optional[str] = None
+    if CONF_ENCRYPTION in conf:
+        noise_psk = conf[CONF_ENCRYPTION][CONF_KEY]
+    _LOGGER.info("Starting log output from %s using esphome API", address)
+    cli = APIClient(
+        address,
+        port,
+        password,
+        client_info=f"ESPHome Logs {__version__}",
+        noise_psk=noise_psk,
+    )
+    first_connect = True
+
+    def on_log(msg):
+        time_ = datetime.now().time().strftime("[%H:%M:%S]")
+        text = msg.message.decode("utf8", "backslashreplace")
+        safe_print(time_ + text)
+
+    async def on_connect():
+        nonlocal first_connect
+        try:
+            await cli.subscribe_logs(
+                on_log,
+                log_level=LogLevel.LOG_LEVEL_VERY_VERBOSE,
+                dump_config=first_connect,
+            )
+            first_connect = False
+        except APIConnectionError:
+            cli.disconnect()
+
+    async def on_disconnect():
+        _LOGGER.warning("Disconnected from API")
+
+    zc = zeroconf.Zeroconf()
+    reconnect = ReconnectLogic(
+        client=cli,
+        on_connect=on_connect,
+        on_disconnect=on_disconnect,
+        zeroconf_instance=zc,
+    )
+    await reconnect.start()
+
+    try:
+        while True:
+            await asyncio.sleep(60)
+    except KeyboardInterrupt:
+        await reconnect.stop()
+        zc.close()
+
+
+def run_logs(config, address):
+    asyncio.run(async_run_logs(config, address))

esphome/components/api/custom_api_device.h

@@ -49,7 +49,7 @@ class CustomAPIDevice {
   template<typename T, typename... Ts>
   void register_service(void (T::*callback)(Ts...), const std::string &name,
                         const std::array<std::string, sizeof...(Ts)> &arg_names) {
-    auto *service = new CustomAPIDeviceService<T, Ts...>(name, arg_names, (T *) this, callback);
+    auto *service = new CustomAPIDeviceService<T, Ts...>(name, arg_names, (T *) this, callback);  // NOLINT
     global_api_server->register_user_service(service);
   }
 
@@ -72,17 +72,17 @@ class CustomAPIDevice {
    * @param name The name of the arguments for the service, must match the arguments of the function.
    */
   template<typename T> void register_service(void (T::*callback)(), const std::string &name) {
-    auto *service = new CustomAPIDeviceService<T>(name, {}, (T *) this, callback);
+    auto *service = new CustomAPIDeviceService<T>(name, {}, (T *) this, callback);  // NOLINT
     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/homeassistant_service.h

@@ -8,6 +8,18 @@
 namespace esphome {
 namespace api {
 
+template<typename... X> class TemplatableStringValue : public TemplatableValue<std::string, X...> {
+ public:
+  TemplatableStringValue() : TemplatableValue<std::string, X...>() {}
+
+  template<typename F, enable_if_t<!is_invocable<F, X...>::value, int> = 0>
+  TemplatableStringValue(F value) : TemplatableValue<std::string, X...>(value) {}
+
+  template<typename F, enable_if_t<is_invocable<F, X...>::value, int> = 0>
+  TemplatableStringValue(F f)
+      : TemplatableValue<std::string, X...>([f](X... x) -> std::string { return to_string(f(x...)); }) {}
+};
+
 template<typename... Ts> class TemplatableKeyValuePair {
  public:
   template<typename T> TemplatableKeyValuePair(std::string key, T value) : key(std::move(key)), value(value) {}
@@ -19,7 +31,8 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
  public:
   explicit HomeAssistantServiceCallAction(APIServer *parent, bool is_event) : parent_(parent), is_event_(is_event) {}
 
-  TEMPLATABLE_STRING_VALUE(service);
+  template<typename T> void set_service(T service) { this->service_ = service; }
+
   template<typename T> void add_data(std::string key, T value) {
     this->data_.push_back(TemplatableKeyValuePair<Ts...>(key, value));
   }
@@ -58,6 +71,7 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
  protected:
   APIServer *parent_;
   bool is_event_;
+  TemplatableStringValue<Ts...> service_{};
   std::vector<TemplatableKeyValuePair<Ts...>> data_;
   std::vector<TemplatableKeyValuePair<Ts...>> data_template_;
   std::vector<TemplatableKeyValuePair<Ts...>> variables_;

esphome/components/api/list_entities.cpp

@@ -16,7 +16,7 @@ bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_
 bool ListEntitiesIterator::on_cover(cover::Cover *cover) { return this->client_->send_cover_info(cover); }
 #endif
 #ifdef USE_FAN
-bool ListEntitiesIterator::on_fan(fan::FanState *fan) { return this->client_->send_fan_info(fan); }
+bool ListEntitiesIterator::on_fan(fan::Fan *fan) { return this->client_->send_fan_info(fan); }
 #endif
 #ifdef USE_LIGHT
 bool ListEntitiesIterator::on_light(light::LightState *light) { return this->client_->send_light_info(light); }
@@ -27,15 +27,20 @@ bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) { return this->clie
 #ifdef USE_SWITCH
 bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) { return this->client_->send_switch_info(a_switch); }
 #endif
+#ifdef USE_BUTTON
+bool ListEntitiesIterator::on_button(button::Button *button) { return this->client_->send_button_info(button); }
+#endif
 #ifdef USE_TEXT_SENSOR
 bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
   return this->client_->send_text_sensor_info(text_sensor);
 }
 #endif
+#ifdef USE_LOCK
+bool ListEntitiesIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_info(a_lock); }
+#endif
 
 bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(); }
-ListEntitiesIterator::ListEntitiesIterator(APIServer *server, APIConnection *client)
-    : ComponentIterator(server), client_(client) {}
+ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(client) {}
 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
   auto resp = service->encode_list_service_response();
   return this->client_->send_list_entities_services_response(resp);
@@ -51,5 +56,19 @@ 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
+
+#ifdef USE_MEDIA_PLAYER
+bool ListEntitiesIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_info(media_player);
+}
+#endif
+
 }  // namespace api
 }  // namespace esphome

esphome/components/api/list_entities.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/component_iterator.h"
 #include "esphome/core/defines.h"
-#include "util.h"
 
 namespace esphome {
 namespace api {
@@ -11,7 +11,7 @@ class APIConnection;
 
 class ListEntitiesIterator : public ComponentIterator {
  public:
-  ListEntitiesIterator(APIServer *server, APIConnection *client);
+  ListEntitiesIterator(APIConnection *client);
 #ifdef USE_BINARY_SENSOR
   bool on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) override;
 #endif
@@ -19,7 +19,7 @@ class ListEntitiesIterator : public ComponentIterator {
   bool on_cover(cover::Cover *cover) override;
 #endif
 #ifdef USE_FAN
-  bool on_fan(fan::FanState *fan) override;
+  bool on_fan(fan::Fan *fan) override;
 #endif
 #ifdef USE_LIGHT
   bool on_light(light::LightState *light) override;
@@ -30,6 +30,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_SWITCH
   bool on_switch(switch_::Switch *a_switch) override;
 #endif
+#ifdef USE_BUTTON
+  bool on_button(button::Button *button) override;
+#endif
 #ifdef USE_TEXT_SENSOR
   bool on_text_sensor(text_sensor::TextSensor *text_sensor) override;
 #endif
@@ -39,6 +42,18 @@ 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
+#ifdef USE_LOCK
+  bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
   bool on_end() override;
 
@@ -48,5 +63,3 @@ class ListEntitiesIterator : public ComponentIterator {
 
 }  // namespace api
 }  // namespace esphome
-
-#include "api_server.h"

esphome/components/api/proto.cpp

@@ -1,11 +1,10 @@
 #include "proto.h"
-#include "util.h"
 #include "esphome/core/log.h"
 
 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 +61,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 +79,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 {
 
@@ -50,17 +55,19 @@ class ProtoVarInt {
   }
   int32_t as_sint32() const {
     // with ZigZag encoding
-    if (this->value_ & 1)
+    if (this->value_ & 1) {
       return static_cast<int32_t>(~(this->value_ >> 1));
-    else
+    } else {
       return static_cast<int32_t>(this->value_ >> 1);
+    }
   }
   int64_t as_sint64() const {
     // with ZigZag encoding
-    if (this->value_ & 1)
+    if (this->value_ & 1) {
       return static_cast<int64_t>(~(this->value_ >> 1));
-    else
+    } else {
       return static_cast<int64_t>(this->value_ >> 1);
+    }
   }
   void encode(std::vector<uint8_t> &out) {
     uint32_t val = this->value_;
@@ -188,6 +195,20 @@ class ProtoWriteBuffer {
     this->write((value >> 16) & 0xFF);
     this->write((value >> 24) & 0xFF);
   }
+  void encode_fixed64(uint32_t field_id, uint64_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+
+    this->encode_field_raw(field_id, 5);
+    this->write((value >> 0) & 0xFF);
+    this->write((value >> 8) & 0xFF);
+    this->write((value >> 16) & 0xFF);
+    this->write((value >> 24) & 0xFF);
+    this->write((value >> 32) & 0xFF);
+    this->write((value >> 40) & 0xFF);
+    this->write((value >> 48) & 0xFF);
+    this->write((value >> 56) & 0xFF);
+  }
   template<typename T> void encode_enum(uint32_t field_id, T value, bool force = false) {
     this->encode_uint32(field_id, static_cast<uint32_t>(value), force);
   }
@@ -215,12 +236,22 @@ class ProtoWriteBuffer {
   }
   void encode_sint32(uint32_t field_id, int32_t value, bool force = false) {
     uint32_t uvalue;
-    if (value < 0)
+    if (value < 0) {
       uvalue = ~(value << 1);
-    else
+    } else {
       uvalue = value << 1;
+    }
     this->encode_uint32(field_id, uvalue, force);
   }
+  void encode_sint64(uint32_t field_id, int64_t value, bool force = false) {
+    uint64_t uvalue;
+    if (value < 0) {
+      uvalue = ~(value << 1);
+    } else {
+      uvalue = value << 1;
+    }
+    this->encode_uint64(field_id, uvalue, force);
+  }
   template<class C> void encode_message(uint32_t field_id, const C &value, bool force = false) {
     this->encode_field_raw(field_id, 2);
     size_t begin = this->buffer_->size();
@@ -241,10 +272,13 @@ class ProtoWriteBuffer {
 
 class ProtoMessage {
  public:
+  virtual ~ProtoMessage() = default;
   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

@@ -14,7 +14,7 @@ bool InitialStateIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_
 bool InitialStateIterator::on_cover(cover::Cover *cover) { return this->client_->send_cover_state(cover); }
 #endif
 #ifdef USE_FAN
-bool InitialStateIterator::on_fan(fan::FanState *fan) { return this->client_->send_fan_state(fan); }
+bool InitialStateIterator::on_fan(fan::Fan *fan) { return this->client_->send_fan_state(fan); }
 #endif
 #ifdef USE_LIGHT
 bool InitialStateIterator::on_light(light::LightState *light) { return this->client_->send_light_state(light); }
@@ -37,8 +37,25 @@ 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
-InitialStateIterator::InitialStateIterator(APIServer *server, APIConnection *client)
-    : ComponentIterator(server), client_(client) {}
+#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
+#ifdef USE_LOCK
+bool InitialStateIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_state(a_lock, a_lock->state); }
+#endif
+#ifdef USE_MEDIA_PLAYER
+bool InitialStateIterator::on_media_player(media_player::MediaPlayer *media_player) {
+  return this->client_->send_media_player_state(media_player);
+}
+#endif
+InitialStateIterator::InitialStateIterator(APIConnection *client) : client_(client) {}
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/subscribe_state.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/component_iterator.h"
 #include "esphome/core/controller.h"
 #include "esphome/core/defines.h"
-#include "util.h"
 
 namespace esphome {
 namespace api {
@@ -12,7 +12,7 @@ class APIConnection;
 
 class InitialStateIterator : public ComponentIterator {
  public:
-  InitialStateIterator(APIServer *server, APIConnection *client);
+  InitialStateIterator(APIConnection *client);
 #ifdef USE_BINARY_SENSOR
   bool on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) override;
 #endif
@@ -20,7 +20,7 @@ class InitialStateIterator : public ComponentIterator {
   bool on_cover(cover::Cover *cover) override;
 #endif
 #ifdef USE_FAN
-  bool on_fan(fan::FanState *fan) override;
+  bool on_fan(fan::Fan *fan) override;
 #endif
 #ifdef USE_LIGHT
   bool on_light(light::LightState *light) override;
@@ -31,11 +31,26 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_SWITCH
   bool on_switch(switch_::Switch *a_switch) override;
 #endif
+#ifdef USE_BUTTON
+  bool on_button(button::Button *button) override { return true; };
+#endif
 #ifdef USE_TEXT_SENSOR
   bool on_text_sensor(text_sensor::TextSensor *text_sensor) override;
 #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
+#ifdef USE_LOCK
+  bool on_lock(lock::Lock *a_lock) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
  protected:
   APIConnection *client_;
@@ -43,5 +58,3 @@ class InitialStateIterator : public ComponentIterator {
 
 }  // namespace api
 }  // namespace esphome
-
-#include "api_server.h"

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_);
   }
 
@@ -50,7 +52,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<int... S> void execute_(std::vector<ExecuteServiceArgument> args, seq<S...>) {
+  template<int... S> void execute_(std::vector<ExecuteServiceArgument> args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 

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, 22, 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...");
@@ -26,6 +26,9 @@ void AS3935Component::setup() {
 void AS3935Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AS3935:");
   LOG_PIN("  Interrupt Pin: ", this->irq_pin_);
+  LOG_BINARY_SENSOR("  ", "Thunder alert", this->thunder_alert_binary_sensor_);
+  LOG_SENSOR("  ", "Distance", this->distance_sensor_);
+  LOG_SENSOR("  ", "Lightning energy", this->energy_sensor_);
 }
 
 float AS3935Component::get_setup_priority() const { return setup_priority::DATA; }
@@ -55,10 +58,11 @@ void AS3935Component::loop() {
 
 void AS3935Component::write_indoor(bool indoor) {
   ESP_LOGV(TAG, "Setting indoor to %d", indoor);
-  if (indoor)
+  if (indoor) {
     this->write_register(AFE_GAIN, GAIN_MASK, INDOOR, 1);
-  else
+  } else {
     this->write_register(AFE_GAIN, GAIN_MASK, OUTDOOR, 1);
+  }
 }
 // REG0x01, bits[3:0], manufacturer default: 0010 (2).
 // This setting determines the threshold for events that trigger the

esphome/components/as3935/as3935.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/hal.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 

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,42 @@
 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,
+    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,
+        ),
+        cv.Optional(CONF_LIGHTNING_ENERGY): sensor.sensor_schema(
+            icon=ICON_FLASH,
+            accuracy_decimals=1,
+        ),
+    }
+).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)
-        cg.add(hub.set_distance_sensor(lightning_energy_sensor))
+        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;
@@ -25,8 +25,12 @@ void I2CAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits,
 
 uint8_t I2CAS3935Component::read_register(uint8_t reg) {
   uint8_t value;
-  if (!this->read_byte(reg, &value, 2)) {
-    ESP_LOGW(TAG, "Read failed!");
+  if (write(&reg, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Writing register failed!");
+    return 0;
+  }
+  if (read(&value, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Reading register failed!");
     return 0;
   }
   return value;

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

@@ -1,15 +1,21 @@
 # Dummy integration to allow relying on AsyncTCP
 import esphome.codegen as cg
+import esphome.config_validation as cv
 from esphome.core import CORE, coroutine_with_priority
 
-CODEOWNERS = ['@OttoWinter']
+CODEOWNERS = ["@OttoWinter"]
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema({}),
+    cv.only_with_arduino,
+)
 
 
 @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.2')
+        cg.add_library("ottowinter/ESPAsyncTCP-esphome", "1.2.3")

esphome/components/atc_mithermometer/atc_mithermometer.cpp

@@ -0,0 +1,133 @@
+#include "atc_mithermometer.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_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.has_value()) {
+      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 (this->signal_strength_ != nullptr)
+    this->signal_strength_->publish_state(device.get_rssi());
+
+  return success;
+}
+
+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 (%hhu).", last_frame_count);
+    return {};
+  }
+  last_frame_count = raw[12];
+
+  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,49 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace atc_mithermometer {
+
+struct ParseResult {
+  optional<float> temperature;
+  optional<float> humidity;
+  optional<float> battery_level;
+  optional<float> battery_voltage;
+  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; }
+  void set_signal_strength(sensor::Sensor *signal_strength) { signal_strength_ = signal_strength; }
+
+ protected:
+  uint64_t address_;
+  sensor::Sensor *temperature_{nullptr};
+  sensor::Sensor *humidity_{nullptr};
+  sensor::Sensor *battery_level_{nullptr};
+  sensor::Sensor *battery_voltage_{nullptr};
+  sensor::Sensor *signal_strength_{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,100 @@
+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_SIGNAL_STRENGTH,
+    CONF_TEMPERATURE,
+    CONF_ID,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_DECIBEL_MILLIWATT,
+    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,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            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,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            cv.Optional(CONF_SIGNAL_STRENGTH): sensor.sensor_schema(
+                unit_of_measurement=UNIT_DECIBEL_MILLIWATT,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
+                state_class=STATE_CLASS_MEASUREMENT,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+        }
+    )
+    .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))
+    if CONF_SIGNAL_STRENGTH in config:
+        sens = await sensor.new_sensor(config[CONF_SIGNAL_STRENGTH])
+        cg.add(var.set_signal_strength(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,60 @@ 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);
+  if ((UINT32_MAX - this->phase_[0].cumulative_forward_active_energy_) > val) {
+    this->phase_[0].cumulative_forward_active_energy_ += val;
+  } else {
+    this->phase_[0].cumulative_forward_active_energy_ = val;
+  }
+  return ((float) this->phase_[0].cumulative_forward_active_energy_ * 10 / 3200);
+}
+float ATM90E32Component::get_forward_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYB);
+  if (UINT32_MAX - this->phase_[1].cumulative_forward_active_energy_ > val) {
+    this->phase_[1].cumulative_forward_active_energy_ += val;
+  } else {
+    this->phase_[1].cumulative_forward_active_energy_ = val;
+  }
+  return ((float) this->phase_[1].cumulative_forward_active_energy_ * 10 / 3200);
+}
+float ATM90E32Component::get_forward_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYC);
+  if (UINT32_MAX - this->phase_[2].cumulative_forward_active_energy_ > val) {
+    this->phase_[2].cumulative_forward_active_energy_ += val;
+  } else {
+    this->phase_[2].cumulative_forward_active_energy_ = val;
+  }
+  return ((float) this->phase_[2].cumulative_forward_active_energy_ * 10 / 3200);
+}
+float ATM90E32Component::get_reverse_active_energy_a_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYA);
+  if (UINT32_MAX - this->phase_[0].cumulative_reverse_active_energy_ > val) {
+    this->phase_[0].cumulative_reverse_active_energy_ += val;
+  } else {
+    this->phase_[0].cumulative_reverse_active_energy_ = val;
+  }
+  return ((float) this->phase_[0].cumulative_reverse_active_energy_ * 10 / 3200);
+}
+float ATM90E32Component::get_reverse_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYB);
+  if (UINT32_MAX - this->phase_[1].cumulative_reverse_active_energy_ > val) {
+    this->phase_[1].cumulative_reverse_active_energy_ += val;
+  } else {
+    this->phase_[1].cumulative_reverse_active_energy_ = val;
+  }
+  return ((float) this->phase_[1].cumulative_reverse_active_energy_ * 10 / 3200);
+}
+float ATM90E32Component::get_reverse_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYC);
+  if (UINT32_MAX - this->phase_[2].cumulative_reverse_active_energy_ > val) {
+    this->phase_[2].cumulative_reverse_active_energy_ += val;
+  } else {
+    this->phase_[2].cumulative_reverse_active_energy_ = val;
+  }
+  return ((float) this->phase_[2].cumulative_reverse_active_energy_ * 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,10 @@ 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};
+    uint32_t cumulative_forward_active_energy_{0};
+    uint32_t cumulative_reverse_active_energy_{0};
   } 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,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_LIGHTBULB,
+    ICON_CURRENT_AC,
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
+    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_TOTAL_INCREASING,
+        ),
+        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_TOTAL_INCREASING,
+        ),
+        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,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            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,108 @@
+#include "b_parasite.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_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_);
+  LOG_SENSOR("  ", "Illuminance", this->illuminance_);
+}
+
+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;
+
+  const uint8_t protocol_version = data[0] >> 4;
+  if (protocol_version != 1 && protocol_version != 2) {
+    ESP_LOGE(TAG, "Unsupported protocol version: %u", protocol_version);
+    return false;
+  }
+
+  // Some b-parasite versions have an (optional) illuminance sensor.
+  bool has_illuminance = data[0] & 0x1;
+
+  // 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 (protocol v1) or 100 * Celsius (protocol v2).
+  float temp_celsius;
+  if (protocol_version == 1) {
+    uint16_t temp_millicelsius = data[4] << 8 | data[5];
+    temp_celsius = temp_millicelsius / 1000.0f;
+  } else {
+    int16_t temp_centicelsius = data[4] << 8 | data[5];
+    temp_celsius = temp_centicelsius / 100.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);
+
+  // Ambient light in lux.
+  float illuminance = has_illuminance ? data[16] << 8 | data[17] : 0.0f;
+
+  if (battery_voltage_ != nullptr) {
+    battery_voltage_->publish_state(battery_voltage);
+  }
+  if (temperature_ != nullptr) {
+    temperature_->publish_state(temp_celsius);
+  }
+  if (humidity_ != nullptr) {
+    humidity_->publish_state(humidity_percent);
+  }
+  if (soil_moisture_ != nullptr) {
+    soil_moisture_->publish_state(moisture_percent);
+  }
+  if (illuminance_ != nullptr) {
+    if (has_illuminance) {
+      illuminance_->publish_state(illuminance);
+    } else {
+      ESP_LOGE(TAG, "No lux information is present in the BLE packet");
+    }
+  }
+
+  last_processed_counter_ = counter;
+  return true;
+}
+
+}  // namespace b_parasite
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/b_parasite/b_parasite.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef USE_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; }
+  void set_illuminance(sensor::Sensor *illuminance) { illuminance_ = illuminance; }
+
+ 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};
+  sensor::Sensor *illuminance_{nullptr};
+};
+
+}  // namespace b_parasite
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/b_parasite/sensor.py

@@ -0,0 +1,92 @@
+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_ILLUMINANCE,
+    CONF_MOISTURE,
+    CONF_MAC_ADDRESS,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_ILLUMINANCE,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_LUX,
+    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,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            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,
+            ),
+            cv.Optional(CONF_ILLUMINANCE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_LUX,
+                accuracy_decimals=0,
+                device_class=DEVICE_CLASS_ILLUMINANCE,
+                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),
+        (CONF_ILLUMINANCE, var.set_illuminance),
+    ]:
+        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,13 @@ 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 +38,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,24 +47,32 @@ 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)) {
+  if (std::isnan(this->current_temperature) || std::isnan(this->target_temperature_low) ||
+      std::isnan(this->target_temperature_high)) {
     // if any control parameters are nan, go to OFF action (not IDLE!)
     this->switch_to_action_(climate::CLIMATE_ACTION_OFF);
     return;
@@ -68,21 +82,25 @@ void BangBangClimate::compute_state_() {
 
   climate::ClimateAction target_action;
   if (too_cold) {
-    // too cold -> enable heating if possible, else idle
-    if (this->supports_heat_)
+    // too cold -> enable heating if possible and enabled, else idle
+    if (this->supports_heat_ &&
+        (this->mode == climate::CLIMATE_MODE_HEAT_COOL || this->mode == climate::CLIMATE_MODE_HEAT)) {
       target_action = climate::CLIMATE_ACTION_HEATING;
-    else
+    } else {
       target_action = climate::CLIMATE_ACTION_IDLE;
+    }
   } else if (too_hot) {
-    // too hot -> enable cooling if possible, else idle
-    if (this->supports_cool_)
+    // too hot -> enable cooling if possible and enabled, else idle
+    if (this->supports_cool_ &&
+        (this->mode == climate::CLIMATE_MODE_HEAT_COOL || this->mode == climate::CLIMATE_MODE_COOL)) {
       target_action = climate::CLIMATE_ACTION_COOLING;
-    else
+    } else {
       target_action = climate::CLIMATE_ACTION_IDLE;
+    }
   } else {
     // neither too hot nor too cold -> in range
-    if (this->supports_cool_ && this->supports_heat_) {
-      // if supports both ends, go to idle action
+    if (this->supports_cool_ && this->supports_heat_ && this->mode == climate::CLIMATE_MODE_HEAT_COOL) {
+      // if supports both ends and both cooling and heating enabled, go to idle action
       target_action = climate::CLIMATE_ACTION_IDLE;
     } else {
       // else use current mode and don't change (hysteresis)
@@ -93,9 +111,10 @@ void BangBangClimate::compute_state_() {
   this->switch_to_action_(target_action);
 }
 void BangBangClimate::switch_to_action_(climate::ClimateAction action) {
-  if (action == this->action)
+  if (action == this->action) {
     // already in target mode
     return;
+  }
 
   if ((action == climate::CLIMATE_ACTION_OFF && this->action == climate::CLIMATE_ACTION_IDLE) ||
       (action == climate::CLIMATE_ACTION_IDLE && this->action == climate::CLIMATE_ACTION_OFF)) {
@@ -140,7 +159,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/bedjet/__init__.py

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

esphome/components/bedjet/bedjet.cpp

@@ -0,0 +1,675 @@
+#include "bedjet.h"
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+
+namespace esphome {
+namespace bedjet {
+
+using namespace esphome::climate;
+
+/// Converts a BedJet temp step into degrees Celsius.
+float bedjet_temp_to_c(const uint8_t temp) {
+  // BedJet temp is "C*2"; to get C, divide by 2.
+  return temp / 2.0f;
+}
+
+/// Converts a BedJet fan step to a speed percentage, in the range of 5% to 100%.
+uint8_t bedjet_fan_step_to_speed(const uint8_t fan) {
+  //  0 =  5%
+  // 19 = 100%
+  return 5 * fan + 5;
+}
+
+static const std::string *bedjet_fan_step_to_fan_mode(const uint8_t fan_step) {
+  if (fan_step >= 0 && fan_step <= 19)
+    return &BEDJET_FAN_STEP_NAME_STRINGS[fan_step];
+  return nullptr;
+}
+
+static uint8_t bedjet_fan_speed_to_step(const std::string &fan_step_percent) {
+  for (int i = 0; i < sizeof(BEDJET_FAN_STEP_NAME_STRINGS); i++) {
+    if (fan_step_percent == BEDJET_FAN_STEP_NAME_STRINGS[i]) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+static BedjetButton heat_button(BedjetHeatMode mode) {
+  BedjetButton btn = BTN_HEAT;
+  if (mode == HEAT_MODE_EXTENDED) {
+    btn = BTN_EXTHT;
+  }
+  return btn;
+}
+
+void Bedjet::upgrade_firmware() {
+  auto *pkt = this->codec_->get_button_request(MAGIC_UPDATE);
+  auto status = this->write_bedjet_packet_(pkt);
+
+  if (status) {
+    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+  }
+}
+
+void Bedjet::dump_config() {
+  LOG_CLIMATE("", "BedJet Climate", this);
+  auto traits = this->get_traits();
+
+  ESP_LOGCONFIG(TAG, "  Supported modes:");
+  for (auto mode : traits.get_supported_modes()) {
+    ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_mode_to_string(mode)));
+  }
+
+  ESP_LOGCONFIG(TAG, "  Supported fan modes:");
+  for (const auto &mode : traits.get_supported_fan_modes()) {
+    ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_fan_mode_to_string(mode)));
+  }
+  for (const auto &mode : traits.get_supported_custom_fan_modes()) {
+    ESP_LOGCONFIG(TAG, "   - %s (c)", mode.c_str());
+  }
+
+  ESP_LOGCONFIG(TAG, "  Supported presets:");
+  for (auto preset : traits.get_supported_presets()) {
+    ESP_LOGCONFIG(TAG, "   - %s", LOG_STR_ARG(climate_preset_to_string(preset)));
+  }
+  for (const auto &preset : traits.get_supported_custom_presets()) {
+    ESP_LOGCONFIG(TAG, "   - %s (c)", preset.c_str());
+  }
+}
+
+void Bedjet::setup() {
+  this->codec_ = make_unique<BedjetCodec>();
+
+  // restore set points
+  auto restore = this->restore_state_();
+  if (restore.has_value()) {
+    ESP_LOGI(TAG, "Restored previous saved state.");
+    restore->apply(this);
+  } else {
+    // Initial status is unknown until we connect
+    this->reset_state_();
+  }
+
+#ifdef USE_TIME
+  this->setup_time_();
+#endif
+}
+
+/** Resets states to defaults. */
+void Bedjet::reset_state_() {
+  this->mode = climate::CLIMATE_MODE_OFF;
+  this->action = climate::CLIMATE_ACTION_IDLE;
+  this->target_temperature = NAN;
+  this->current_temperature = NAN;
+  this->preset.reset();
+  this->custom_preset.reset();
+  this->publish_state();
+}
+
+void Bedjet::loop() {}
+
+void Bedjet::control(const ClimateCall &call) {
+  ESP_LOGD(TAG, "Received Bedjet::control");
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    ESP_LOGW(TAG, "Not connected, cannot handle control call yet.");
+    return;
+  }
+
+  if (call.get_mode().has_value()) {
+    ClimateMode mode = *call.get_mode();
+    BedjetPacket *pkt;
+    switch (mode) {
+      case climate::CLIMATE_MODE_OFF:
+        pkt = this->codec_->get_button_request(BTN_OFF);
+        break;
+      case climate::CLIMATE_MODE_HEAT:
+        pkt = this->codec_->get_button_request(heat_button(this->heating_mode_));
+        break;
+      case climate::CLIMATE_MODE_FAN_ONLY:
+        pkt = this->codec_->get_button_request(BTN_COOL);
+        break;
+      case climate::CLIMATE_MODE_DRY:
+        pkt = this->codec_->get_button_request(BTN_DRY);
+        break;
+      default:
+        ESP_LOGW(TAG, "Unsupported mode: %d", mode);
+        return;
+    }
+
+    auto status = this->write_bedjet_packet_(pkt);
+
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    } else {
+      this->force_refresh_ = true;
+      this->mode = mode;
+      // We're using (custom) preset for Turbo, EXT HT, & M1-3 presets, so changing climate mode will clear those
+      this->custom_preset.reset();
+      this->preset.reset();
+    }
+  }
+
+  if (call.get_target_temperature().has_value()) {
+    auto target_temp = *call.get_target_temperature();
+    auto *pkt = this->codec_->get_set_target_temp_request(target_temp);
+    auto status = this->write_bedjet_packet_(pkt);
+
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    } else {
+      this->target_temperature = target_temp;
+    }
+  }
+
+  if (call.get_preset().has_value()) {
+    ClimatePreset preset = *call.get_preset();
+    BedjetPacket *pkt;
+
+    if (preset == climate::CLIMATE_PRESET_BOOST) {
+      pkt = this->codec_->get_button_request(BTN_TURBO);
+    } else {
+      ESP_LOGW(TAG, "Unsupported preset: %d", preset);
+      return;
+    }
+
+    auto status = this->write_bedjet_packet_(pkt);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    } else {
+      // We use BOOST preset for TURBO mode, which is a short-lived/high-heat mode.
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->preset = preset;
+      this->custom_preset.reset();
+      this->force_refresh_ = true;
+    }
+  } else if (call.get_custom_preset().has_value()) {
+    std::string preset = *call.get_custom_preset();
+    BedjetPacket *pkt;
+
+    if (preset == "M1") {
+      pkt = this->codec_->get_button_request(BTN_M1);
+    } else if (preset == "M2") {
+      pkt = this->codec_->get_button_request(BTN_M2);
+    } else if (preset == "M3") {
+      pkt = this->codec_->get_button_request(BTN_M3);
+    } else if (preset == "LTD HT") {
+      pkt = this->codec_->get_button_request(BTN_HEAT);
+    } else if (preset == "EXT HT") {
+      pkt = this->codec_->get_button_request(BTN_EXTHT);
+    } else {
+      ESP_LOGW(TAG, "Unsupported preset: %s", preset.c_str());
+      return;
+    }
+
+    auto status = this->write_bedjet_packet_(pkt);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    } else {
+      this->force_refresh_ = true;
+      this->custom_preset = preset;
+      this->preset.reset();
+    }
+  }
+
+  if (call.get_fan_mode().has_value()) {
+    // Climate fan mode only supports low/med/high, but the BedJet supports 5-100% increments.
+    // We can still support a ClimateCall that requests low/med/high, and just translate it to a step increment here.
+    auto fan_mode = *call.get_fan_mode();
+    BedjetPacket *pkt;
+    if (fan_mode == climate::CLIMATE_FAN_LOW) {
+      pkt = this->codec_->get_set_fan_speed_request(3 /* = 20% */);
+    } else if (fan_mode == climate::CLIMATE_FAN_MEDIUM) {
+      pkt = this->codec_->get_set_fan_speed_request(9 /* = 50% */);
+    } else if (fan_mode == climate::CLIMATE_FAN_HIGH) {
+      pkt = this->codec_->get_set_fan_speed_request(14 /* = 75% */);
+    } else {
+      ESP_LOGW(TAG, "[%s] Unsupported fan mode: %s", this->get_name().c_str(),
+               LOG_STR_ARG(climate_fan_mode_to_string(fan_mode)));
+      return;
+    }
+
+    auto status = this->write_bedjet_packet_(pkt);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    } else {
+      this->force_refresh_ = true;
+    }
+  } else if (call.get_custom_fan_mode().has_value()) {
+    auto fan_mode = *call.get_custom_fan_mode();
+    auto fan_step = bedjet_fan_speed_to_step(fan_mode);
+    if (fan_step >= 0 && fan_step <= 19) {
+      ESP_LOGV(TAG, "[%s] Converted fan mode %s to bedjet fan step %d", this->get_name().c_str(), fan_mode.c_str(),
+               fan_step);
+      // The index should represent the fan_step index.
+      BedjetPacket *pkt = this->codec_->get_set_fan_speed_request(fan_step);
+      auto status = this->write_bedjet_packet_(pkt);
+      if (status) {
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+      } else {
+        this->force_refresh_ = true;
+      }
+    }
+  }
+}
+
+void Bedjet::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: {
+      ESP_LOGV(TAG, "Disconnected: reason=%d", param->disconnect.reason);
+      this->status_set_warning();
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      auto *chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_COMMAND_UUID);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "[%s] No control service found at device, not a BedJet..?", this->get_name().c_str());
+        break;
+      }
+      this->char_handle_cmd_ = chr->handle;
+
+      chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_STATUS_UUID);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "[%s] No status service found at device, not a BedJet..?", this->get_name().c_str());
+        break;
+      }
+
+      this->char_handle_status_ = chr->handle;
+      // We also need to obtain the config descriptor for this handle.
+      // Otherwise once we set node_state=Established, the parent will flush all handles/descriptors, and we won't be
+      // able to look it up.
+      auto *descr = this->parent_->get_config_descriptor(this->char_handle_status_);
+      if (descr == nullptr) {
+        ESP_LOGW(TAG, "No config descriptor for status handle 0x%x. Will not be able to receive status notifications",
+                 this->char_handle_status_);
+      } else 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, "Config descriptor 0x%x (uuid %s) is not a client config char uuid", this->char_handle_status_,
+                 descr->uuid.to_string().c_str());
+      } else {
+        this->config_descr_status_ = descr->handle;
+      }
+
+      chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_NAME_UUID);
+      if (chr != nullptr) {
+        this->char_handle_name_ = chr->handle;
+        auto status = esp_ble_gattc_read_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_name_,
+                                              ESP_GATT_AUTH_REQ_NONE);
+        if (status) {
+          ESP_LOGI(TAG, "[%s] Unable to read name characteristic: %d", this->get_name().c_str(), status);
+        }
+      }
+
+      ESP_LOGD(TAG, "Services complete: obtained char handles.");
+      this->node_state = espbt::ClientState::ESTABLISHED;
+
+      this->set_notify_(true);
+
+#ifdef USE_TIME
+      if (this->time_id_.has_value()) {
+        this->send_local_time();
+      }
+#endif
+      break;
+    }
+    case ESP_GATTC_WRITE_DESCR_EVT: {
+      if (param->write.status != ESP_GATT_OK) {
+        // ESP_GATT_INVALID_ATTR_LEN
+        ESP_LOGW(TAG, "Error writing descr at handle 0x%04d, status=%d", param->write.handle, param->write.status);
+        break;
+      }
+      // [16:44:44][V][bedjet:279]: [JOENJET] Register for notify event success: h=0x002a s=0
+      // This might be the enable-notify descriptor? (or disable-notify)
+      ESP_LOGV(TAG, "[%s] Write to handle 0x%04x status=%d", this->get_name().c_str(), param->write.handle,
+               param->write.status);
+      break;
+    }
+    case ESP_GATTC_WRITE_CHAR_EVT: {
+      if (param->write.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "Error writing char at handle 0x%04d, status=%d", param->write.handle, param->write.status);
+        break;
+      }
+      if (param->write.handle == this->char_handle_cmd_) {
+        if (this->force_refresh_) {
+          // Command write was successful. Publish the pending state, hoping that notify will kick in.
+          this->publish_state();
+        }
+      }
+      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->char_handle_status_) {
+        // This is the additional packet that doesn't fit in the notify packet.
+        this->codec_->decode_extra(param->read.value, param->read.value_len);
+      } else if (param->read.handle == this->char_handle_name_) {
+        // The data should represent the name.
+        if (param->read.status == ESP_GATT_OK && param->read.value_len > 0) {
+          std::string bedjet_name(reinterpret_cast<char const *>(param->read.value), param->read.value_len);
+          // this->set_name(bedjet_name);
+          ESP_LOGV(TAG, "[%s] Got BedJet name: '%s'", this->get_name().c_str(), bedjet_name.c_str());
+        }
+      }
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      // This event means that ESP received the request to enable notifications on the client side. But we also have to
+      // tell the server that we want it to send notifications. Normally BLEClient parent would handle this
+      // automatically, but as soon as we set our status to Established, the parent is going to purge all the
+      // service/char/descriptor handles, and then get_config_descriptor() won't work anymore. There's no way to disable
+      // the BLEClient parent behavior, so our only option is to write the handle anyway, and hope a double-write
+      // doesn't break anything.
+
+      if (param->reg_for_notify.handle != this->char_handle_status_) {
+        ESP_LOGW(TAG, "[%s] Register for notify on unexpected handle 0x%04x, expecting 0x%04x",
+                 this->get_name().c_str(), param->reg_for_notify.handle, this->char_handle_status_);
+        break;
+      }
+
+      this->write_notify_config_descriptor_(true);
+      this->last_notify_ = 0;
+      this->force_refresh_ = true;
+      break;
+    }
+    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT: {
+      // This event is not handled by the parent BLEClient, so we need to do this either way.
+      if (param->unreg_for_notify.handle != this->char_handle_status_) {
+        ESP_LOGW(TAG, "[%s] Unregister for notify on unexpected handle 0x%04x, expecting 0x%04x",
+                 this->get_name().c_str(), param->unreg_for_notify.handle, this->char_handle_status_);
+        break;
+      }
+
+      this->write_notify_config_descriptor_(false);
+      this->last_notify_ = 0;
+      // Now we wait until the next update() poll to re-register notify...
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.handle != this->char_handle_status_) {
+        ESP_LOGW(TAG, "[%s] Unexpected notify handle, wanted %04X, got %04X", this->get_name().c_str(),
+                 this->char_handle_status_, param->notify.handle);
+        break;
+      }
+
+      // FIXME: notify events come in every ~200-300 ms, which is too fast to be helpful. So we
+      //  throttle the updates to once every MIN_NOTIFY_THROTTLE (5 seconds).
+      //  Another idea would be to keep notify off by default, and use update() as an opportunity to turn on
+      //  notify to get enough data to update status, then turn off notify again.
+
+      uint32_t now = millis();
+      auto delta = now - this->last_notify_;
+
+      if (this->last_notify_ == 0 || delta > MIN_NOTIFY_THROTTLE || this->force_refresh_) {
+        bool needs_extra = this->codec_->decode_notify(param->notify.value, param->notify.value_len);
+        this->last_notify_ = now;
+
+        if (needs_extra) {
+          // this means the packet was partial, so read the status characteristic to get the second part.
+          auto status = esp_ble_gattc_read_char(this->parent_->gattc_if, this->parent_->conn_id,
+                                                this->char_handle_status_, ESP_GATT_AUTH_REQ_NONE);
+          if (status) {
+            ESP_LOGI(TAG, "[%s] Unable to read extended status packet", this->get_name().c_str());
+          }
+        }
+
+        if (this->force_refresh_) {
+          // If we requested an immediate update, do that now.
+          this->update();
+          this->force_refresh_ = false;
+        }
+      }
+      break;
+    }
+    default:
+      ESP_LOGVV(TAG, "[%s] gattc unhandled event: enum=%d", this->get_name().c_str(), event);
+      break;
+  }
+}
+
+/** Reimplementation of BLEClient.gattc_event_handler() for ESP_GATTC_REG_FOR_NOTIFY_EVT.
+ *
+ * This is a copy of ble_client's automatic handling of `ESP_GATTC_REG_FOR_NOTIFY_EVT`, in order
+ * to undo the same on unregister. It also allows us to maintain the config descriptor separately,
+ * since the parent BLEClient is going to purge all descriptors once we set our connection status
+ * to `Established`.
+ */
+uint8_t Bedjet::write_notify_config_descriptor_(bool enable) {
+  auto handle = this->config_descr_status_;
+  if (handle == 0) {
+    ESP_LOGW(TAG, "No descriptor found for notify of handle 0x%x", this->char_handle_status_);
+    return -1;
+  }
+
+  // NOTE: BLEClient uses `uint8_t*` of length 1, but BLE spec requires 16 bits.
+  uint8_t notify_en[] = {0, 0};
+  notify_en[0] = enable;
+  auto status =
+      esp_ble_gattc_write_char_descr(this->parent_->gattc_if, this->parent_->conn_id, handle, sizeof(notify_en),
+                                     &notify_en[0], ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
+  if (status) {
+    ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
+    return status;
+  }
+  ESP_LOGD(TAG, "[%s] wrote notify=%s to status config 0x%04x", this->get_name().c_str(), enable ? "true" : "false",
+           handle);
+  return ESP_GATT_OK;
+}
+
+#ifdef USE_TIME
+/** Attempts to sync the local time (via `time_id`) to the BedJet device. */
+void Bedjet::send_local_time() {
+  if (this->time_id_.has_value()) {
+    auto *time_id = *this->time_id_;
+    time::ESPTime now = time_id->now();
+    if (now.is_valid()) {
+      this->set_clock(now.hour, now.minute);
+      ESP_LOGD(TAG, "Using time component to set BedJet clock: %d:%02d", now.hour, now.minute);
+    }
+  } else {
+    ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
+  }
+}
+
+/** Initializes time sync callbacks to support syncing current time to the BedJet. */
+void Bedjet::setup_time_() {
+  if (this->time_id_.has_value()) {
+    this->send_local_time();
+    auto *time_id = *this->time_id_;
+    time_id->add_on_time_sync_callback([this] { this->send_local_time(); });
+  } else {
+    ESP_LOGI(TAG, "`time_id` is not configured: will not sync BedJet clock.");
+  }
+}
+#endif
+
+/** Attempt to set the BedJet device's clock to the specified time. */
+void Bedjet::set_clock(uint8_t hour, uint8_t minute) {
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
+    return;
+  }
+
+  BedjetPacket *pkt = this->codec_->get_set_time_request(hour, minute);
+  auto status = this->write_bedjet_packet_(pkt);
+  if (status) {
+    ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
+  } else {
+    ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
+  }
+}
+
+/** Writes one BedjetPacket to the BLE client on the BEDJET_COMMAND_UUID. */
+uint8_t Bedjet::write_bedjet_packet_(BedjetPacket *pkt) {
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    if (!this->parent_->enabled) {
+      ESP_LOGI(TAG, "[%s] Cannot write packet: Not connected, enabled=false", this->get_name().c_str());
+    } else {
+      ESP_LOGW(TAG, "[%s] Cannot write packet: Not connected", this->get_name().c_str());
+    }
+    return -1;
+  }
+  auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_cmd_,
+                                         pkt->data_length + 1, (uint8_t *) &pkt->command, ESP_GATT_WRITE_TYPE_NO_RSP,
+                                         ESP_GATT_AUTH_REQ_NONE);
+  return status;
+}
+
+/** Configures the local ESP BLE client to register (`true`) or unregister (`false`) for status notifications. */
+uint8_t Bedjet::set_notify_(const bool enable) {
+  uint8_t status;
+  if (enable) {
+    status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->remote_bda,
+                                               this->char_handle_status_);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
+    }
+  } else {
+    status = esp_ble_gattc_unregister_for_notify(this->parent_->gattc_if, this->parent_->remote_bda,
+                                                 this->char_handle_status_);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_unregister_for_notify failed, status=%d", this->get_name().c_str(), status);
+    }
+  }
+  ESP_LOGV(TAG, "[%s] set_notify: enable=%d; result=%d", this->get_name().c_str(), enable, status);
+  return status;
+}
+
+/** Attempts to update the climate device from the last received BedjetStatusPacket.
+ *
+ * @return `true` if the status has been applied; `false` if there is nothing to apply.
+ */
+bool Bedjet::update_status_() {
+  if (!this->codec_->has_status())
+    return false;
+
+  BedjetStatusPacket status = *this->codec_->get_status_packet();
+
+  auto converted_temp = bedjet_temp_to_c(status.target_temp_step);
+  if (converted_temp > 0)
+    this->target_temperature = converted_temp;
+  converted_temp = bedjet_temp_to_c(status.ambient_temp_step);
+  if (converted_temp > 0)
+    this->current_temperature = converted_temp;
+
+  const auto *fan_mode_name = bedjet_fan_step_to_fan_mode(status.fan_step);
+  if (fan_mode_name != nullptr) {
+    this->custom_fan_mode = *fan_mode_name;
+  }
+
+  // TODO: Get biorhythm data to determine which preset (M1-3) is running, if any.
+  switch (status.mode) {
+    case MODE_WAIT:  // Biorhythm "wait" step: device is idle
+    case MODE_STANDBY:
+      this->mode = climate::CLIMATE_MODE_OFF;
+      this->action = climate::CLIMATE_ACTION_IDLE;
+      this->fan_mode = climate::CLIMATE_FAN_OFF;
+      this->custom_preset.reset();
+      this->preset.reset();
+      break;
+
+    case MODE_HEAT:
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->action = climate::CLIMATE_ACTION_HEATING;
+      this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->set_custom_preset_("LTD HT");
+      } else {
+        this->custom_preset.reset();
+      }
+      break;
+
+    case MODE_EXTHT:
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->action = climate::CLIMATE_ACTION_HEATING;
+      this->preset.reset();
+      if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+        this->custom_preset.reset();
+      } else {
+        this->set_custom_preset_("EXT HT");
+      }
+      break;
+
+    case MODE_COOL:
+      this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+      this->action = climate::CLIMATE_ACTION_COOLING;
+      this->custom_preset.reset();
+      this->preset.reset();
+      break;
+
+    case MODE_DRY:
+      this->mode = climate::CLIMATE_MODE_DRY;
+      this->action = climate::CLIMATE_ACTION_DRYING;
+      this->custom_preset.reset();
+      this->preset.reset();
+      break;
+
+    case MODE_TURBO:
+      this->preset = climate::CLIMATE_PRESET_BOOST;
+      this->custom_preset.reset();
+      this->mode = climate::CLIMATE_MODE_HEAT;
+      this->action = climate::CLIMATE_ACTION_HEATING;
+      break;
+
+    default:
+      ESP_LOGW(TAG, "[%s] Unexpected mode: 0x%02X", this->get_name().c_str(), status.mode);
+      break;
+  }
+
+  if (this->is_valid_()) {
+    this->publish_state();
+    this->codec_->clear_status();
+    this->status_clear_warning();
+  }
+
+  return true;
+}
+
+void Bedjet::update() {
+  ESP_LOGV(TAG, "[%s] update()", this->get_name().c_str());
+
+  if (this->node_state != espbt::ClientState::ESTABLISHED) {
+    if (!this->parent()->enabled) {
+      ESP_LOGD(TAG, "[%s] Not connected, because enabled=false", this->get_name().c_str());
+    } else {
+      // Possibly still trying to connect.
+      ESP_LOGD(TAG, "[%s] Not connected, enabled=true", this->get_name().c_str());
+    }
+
+    return;
+  }
+
+  auto result = this->update_status_();
+  if (!result) {
+    uint32_t now = millis();
+    uint32_t diff = now - this->last_notify_;
+
+    if (this->last_notify_ == 0) {
+      // This means we're connected and haven't received a notification, so it likely means that the BedJet is off.
+      // However, it could also mean that it's running, but failing to send notifications.
+      // We can try to unregister for notifications now, and then re-register, hoping to clear it up...
+      // But how do we know for sure which state we're in, and how do we actually clear out the buggy state?
+
+      ESP_LOGI(TAG, "[%s] Still waiting for first GATT notify event.", this->get_name().c_str());
+      this->set_notify_(false);
+    } else if (diff > NOTIFY_WARN_THRESHOLD) {
+      ESP_LOGW(TAG, "[%s] Last GATT notify was %d seconds ago.", this->get_name().c_str(), diff / 1000);
+    }
+
+    if (this->timeout_ > 0 && diff > this->timeout_ && this->parent()->enabled) {
+      ESP_LOGW(TAG, "[%s] Timed out after %d sec. Retrying...", this->get_name().c_str(), this->timeout_);
+      this->parent()->set_enabled(false);
+      this->parent()->set_enabled(true);
+    }
+  }
+}
+
+}  // namespace bedjet
+}  // namespace esphome
+
+#endif

esphome/components/bedjet/bedjet.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#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 "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/hal.h"
+#include "bedjet_base.h"
+
+#ifdef USE_TIME
+#include "esphome/components/time/real_time_clock.h"
+#endif
+
+#ifdef USE_ESP32
+
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace bedjet {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+static const espbt::ESPBTUUID BEDJET_SERVICE_UUID = espbt::ESPBTUUID::from_raw("00001000-bed0-0080-aa55-4265644a6574");
+static const espbt::ESPBTUUID BEDJET_STATUS_UUID = espbt::ESPBTUUID::from_raw("00002000-bed0-0080-aa55-4265644a6574");
+static const espbt::ESPBTUUID BEDJET_COMMAND_UUID = espbt::ESPBTUUID::from_raw("00002004-bed0-0080-aa55-4265644a6574");
+static const espbt::ESPBTUUID BEDJET_NAME_UUID = espbt::ESPBTUUID::from_raw("00002001-bed0-0080-aa55-4265644a6574");
+
+class Bedjet : 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::AFTER_WIFI; }
+
+#ifdef USE_TIME
+  void set_time_id(time::RealTimeClock *time_id) { this->time_id_ = time_id; }
+  void send_local_time();
+#endif
+  void set_clock(uint8_t hour, uint8_t minute);
+  void set_status_timeout(uint32_t timeout) { this->timeout_ = timeout; }
+  /** Sets the default strategy to use for climate::CLIMATE_MODE_HEAT. */
+  void set_heating_mode(BedjetHeatMode mode) { this->heating_mode_ = mode; }
+
+  /** Attempts to check for and apply firmware updates. */
+  void upgrade_firmware();
+
+  climate::ClimateTraits traits() override {
+    auto traits = climate::ClimateTraits();
+    traits.set_supports_action(true);
+    traits.set_supports_current_temperature(true);
+    traits.set_supported_modes({
+        climate::CLIMATE_MODE_OFF,
+        climate::CLIMATE_MODE_HEAT,
+        // climate::CLIMATE_MODE_TURBO // Not supported by Climate: see presets instead
+        climate::CLIMATE_MODE_FAN_ONLY,
+        climate::CLIMATE_MODE_DRY,
+    });
+
+    // It would be better if we had a slider for the fan modes.
+    traits.set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES_SET);
+    traits.set_supported_presets({
+        // If we support NONE, then have to decide what happens if the user switches to it (turn off?)
+        // climate::CLIMATE_PRESET_NONE,
+        // Climate doesn't have a "TURBO" mode, but we can use the BOOST preset instead.
+        climate::CLIMATE_PRESET_BOOST,
+    });
+    traits.set_supported_custom_presets({
+        // We could fetch biodata from bedjet and set these names that way.
+        // But then we have to invert the lookup in order to send the right preset.
+        // For now, we can leave them as M1-3 to match the remote buttons.
+        // EXT HT added to match remote button.
+        "EXT HT",
+        "M1",
+        "M2",
+        "M3",
+    });
+    if (this->heating_mode_ == HEAT_MODE_EXTENDED) {
+      traits.add_supported_custom_preset("LTD HT");
+    } else {
+      traits.add_supported_custom_preset("EXT HT");
+    }
+    traits.set_visual_min_temperature(19.0);
+    traits.set_visual_max_temperature(43.0);
+    traits.set_visual_temperature_step(1.0);
+    return traits;
+  }
+
+ protected:
+  void control(const climate::ClimateCall &call) override;
+
+#ifdef USE_TIME
+  void setup_time_();
+  optional<time::RealTimeClock *> time_id_{};
+#endif
+
+  uint32_t timeout_{DEFAULT_STATUS_TIMEOUT};
+  BedjetHeatMode heating_mode_ = HEAT_MODE_HEAT;
+
+  static const uint32_t MIN_NOTIFY_THROTTLE = 5000;
+  static const uint32_t NOTIFY_WARN_THRESHOLD = 300000;
+  static const uint32_t DEFAULT_STATUS_TIMEOUT = 900000;
+
+  uint8_t set_notify_(bool enable);
+  uint8_t write_bedjet_packet_(BedjetPacket *pkt);
+  void reset_state_();
+  bool update_status_();
+
+  bool is_valid_() {
+    // FIXME: find a better way to check this?
+    return !std::isnan(this->current_temperature) && !std::isnan(this->target_temperature) &&
+           this->current_temperature > 1 && this->target_temperature > 1;
+  }
+
+  uint32_t last_notify_ = 0;
+  bool force_refresh_ = false;
+
+  std::unique_ptr<BedjetCodec> codec_;
+  uint16_t char_handle_cmd_;
+  uint16_t char_handle_name_;
+  uint16_t char_handle_status_;
+  uint16_t config_descr_status_;
+
+  uint8_t write_notify_config_descriptor_(bool enable);
+};
+
+}  // namespace bedjet
+}  // namespace esphome
+
+#endif

esphome/components/bedjet/bedjet_base.cpp

@@ -0,0 +1,123 @@
+#include "bedjet_base.h"
+#include <cstdio>
+#include <cstring>
+
+namespace esphome {
+namespace bedjet {
+
+/// Converts a BedJet temp step into degrees Fahrenheit.
+float bedjet_temp_to_f(const uint8_t temp) {
+  // BedJet temp is "C*2"; to get F, multiply by 0.9 (half 1.8) and add 32.
+  return 0.9f * temp + 32.0f;
+}
+
+/** Cleans up the packet before sending. */
+BedjetPacket *BedjetCodec::clean_packet_() {
+  // So far no commands require more than 2 bytes of data.
+  assert(this->packet_.data_length <= 2);
+  for (int i = this->packet_.data_length; i < 2; i++) {
+    this->packet_.data[i] = '\0';
+  }
+  ESP_LOGV(TAG, "Created packet: %02X, %02X %02X", this->packet_.command, this->packet_.data[0], this->packet_.data[1]);
+  return &this->packet_;
+}
+
+/** Returns a BedjetPacket that will initiate a BedjetButton press. */
+BedjetPacket *BedjetCodec::get_button_request(BedjetButton button) {
+  this->packet_.command = CMD_BUTTON;
+  this->packet_.data_length = 1;
+  this->packet_.data[0] = button;
+  return this->clean_packet_();
+}
+
+/** Returns a BedjetPacket that will set the device's target `temperature`. */
+BedjetPacket *BedjetCodec::get_set_target_temp_request(float temperature) {
+  this->packet_.command = CMD_SET_TEMP;
+  this->packet_.data_length = 1;
+  this->packet_.data[0] = temperature * 2;
+  return this->clean_packet_();
+}
+
+/** Returns a BedjetPacket that will set the device's target fan speed. */
+BedjetPacket *BedjetCodec::get_set_fan_speed_request(const uint8_t fan_step) {
+  this->packet_.command = CMD_SET_FAN;
+  this->packet_.data_length = 1;
+  this->packet_.data[0] = fan_step;
+  return this->clean_packet_();
+}
+
+/** Returns a BedjetPacket that will set the device's current time. */
+BedjetPacket *BedjetCodec::get_set_time_request(const uint8_t hour, const uint8_t minute) {
+  this->packet_.command = CMD_SET_TIME;
+  this->packet_.data_length = 2;
+  this->packet_.data[0] = hour;
+  this->packet_.data[1] = minute;
+  return this->clean_packet_();
+}
+
+/** Decodes the extra bytes that were received after being notified with a partial packet. */
+void BedjetCodec::decode_extra(const uint8_t *data, uint16_t length) {
+  ESP_LOGV(TAG, "Received extra: %d bytes: %d %d %d %d", length, data[1], data[2], data[3], data[4]);
+  uint8_t offset = this->last_buffer_size_;
+  if (offset > 0 && length + offset <= sizeof(BedjetStatusPacket)) {
+    memcpy(((uint8_t *) (&this->buf_)) + offset, data, length);
+    ESP_LOGV(TAG,
+             "Extra bytes: skip1=0x%08x, skip2=0x%04x, skip3=0x%02x; update phase=0x%02x, "
+             "flags=BedjetFlags <conn=%c, leds=%c, units=%c, mute=%c, others=%02x>",
+             this->buf_._skip_1_, this->buf_._skip_2_, this->buf_._skip_3_, this->buf_.update_phase,
+             this->buf_.flags & 0x20 ? '1' : '0', this->buf_.flags & 0x10 ? '1' : '0',
+             this->buf_.flags & 0x04 ? '1' : '0', this->buf_.flags & 0x01 ? '1' : '0',
+             this->buf_.flags & ~(0x20 | 0x10 | 0x04 | 0x01));
+  } else {
+    ESP_LOGI(TAG, "Could not determine where to append to, last offset=%d, max size=%u, new size would be %d", offset,
+             sizeof(BedjetStatusPacket), length + offset);
+  }
+}
+
+/** Decodes the incoming status packet received on the BEDJET_STATUS_UUID.
+ *
+ * @return `true` if the packet was decoded and represents a "partial" packet; `false` otherwise.
+ */
+bool BedjetCodec::decode_notify(const uint8_t *data, uint16_t length) {
+  ESP_LOGV(TAG, "Received: %d bytes: %d %d %d %d", length, data[1], data[2], data[3], data[4]);
+
+  if (data[1] == PACKET_FORMAT_V3_HOME && data[3] == PACKET_TYPE_STATUS) {
+    this->status_packet_.reset();
+
+    // Clear old buffer
+    memset(&this->buf_, 0, sizeof(BedjetStatusPacket));
+    // Copy new data into buffer
+    memcpy(&this->buf_, data, length);
+    this->last_buffer_size_ = length;
+
+    // TODO: validate the packet checksum?
+    if (this->buf_.mode >= 0 && this->buf_.mode < 7 && this->buf_.target_temp_step >= 38 &&
+        this->buf_.target_temp_step <= 86 && this->buf_.actual_temp_step > 1 && this->buf_.actual_temp_step <= 100 &&
+        this->buf_.ambient_temp_step > 1 && this->buf_.ambient_temp_step <= 100) {
+      // and save it for the update() loop
+      this->status_packet_ = this->buf_;
+      return this->buf_.is_partial == 1;
+    } else {
+      // TODO: log a warning if we detect that we connected to a non-V3 device.
+      ESP_LOGW(TAG, "Received potentially invalid packet (len %d):", length);
+    }
+  } else if (data[1] == PACKET_FORMAT_DEBUG || data[3] == PACKET_TYPE_DEBUG) {
+    // We don't actually know the packet format for this. Dump packets to log, in case a pattern presents itself.
+    ESP_LOGV(TAG,
+             "received DEBUG packet: set1=%01fF, set2=%01fF, air=%01fF;  [7]=%d, [8]=%d, [9]=%d, [10]=%d, [11]=%d, "
+             "[12]=%d, [-1]=%d",
+             bedjet_temp_to_f(data[4]), bedjet_temp_to_f(data[5]), bedjet_temp_to_f(data[6]), data[7], data[8], data[9],
+             data[10], data[11], data[12], data[length - 1]);
+
+    if (this->has_status()) {
+      this->status_packet_->ambient_temp_step = data[6];
+    }
+  } else {
+    // TODO: log a warning if we detect that we connected to a non-V3 device.
+  }
+
+  return false;
+}
+
+}  // namespace bedjet
+}  // namespace esphome

esphome/components/bedjet/bedjet_base.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#include "bedjet_const.h"
+
+namespace esphome {
+namespace bedjet {
+
+struct BedjetPacket {
+  uint8_t data_length;
+  BedjetCommand command;
+  uint8_t data[2];
+};
+
+struct BedjetFlags {
+  /* uint8_t */
+  int a_ : 1;                // 0x80
+  int b_ : 1;                // 0x40
+  int conn_test_passed : 1;  ///< (0x20) Bit is set `1` if the last connection test passed.
+  int leds_enabled : 1;      ///< (0x10) Bit is set `1` if the LEDs on the device are enabled.
+  int c_ : 1;                // 0x08
+  int units_setup : 1;       ///< (0x04) Bit is set `1` if the device's units have been configured.
+  int d_ : 1;                // 0x02
+  int beeps_muted : 1;       ///< (0x01) Bit is set `1` if the device's sound output is muted.
+} __attribute__((packed));
+
+enum BedjetPacketFormat : uint8_t {
+  PACKET_FORMAT_DEBUG = 0x05,    //  5
+  PACKET_FORMAT_V3_HOME = 0x56,  // 86
+};
+
+enum BedjetPacketType : uint8_t {
+  PACKET_TYPE_STATUS = 0x1,
+  PACKET_TYPE_DEBUG = 0x2,
+};
+
+/** The format of a BedJet V3 status packet. */
+struct BedjetStatusPacket {
+  // [0]
+  uint8_t is_partial : 8;  ///< `1` indicates that this is a partial packet, and more data can be read directly from the
+                           ///< characteristic.
+  BedjetPacketFormat packet_format : 8;  ///< BedjetPacketFormat::PACKET_FORMAT_V3_HOME for BedJet V3 status packet
+                                         ///< format. BedjetPacketFormat::PACKET_FORMAT_DEBUG for debugging packets.
+  uint8_t
+      expecting_length : 8;  ///< The expected total length of the status packet after merging the additional packet.
+  BedjetPacketType packet_type : 8;  ///< Typically BedjetPacketType::PACKET_TYPE_STATUS for BedJet V3 status packet.
+
+  // [4]
+  uint8_t time_remaining_hrs : 8;   ///< Hours remaining in program runtime
+  uint8_t time_remaining_mins : 8;  ///< Minutes remaining in program runtime
+  uint8_t time_remaining_secs : 8;  ///< Seconds remaining in program runtime
+
+  // [7]
+  uint8_t actual_temp_step : 8;  ///< Actual temp of the air blown by the BedJet fan; value represents `2 *
+                                 ///< degrees_celsius`. See #bedjet_temp_to_c and #bedjet_temp_to_f
+  uint8_t target_temp_step : 8;  ///< Target temp that the BedJet will try to heat to. See #actual_temp_step.
+
+  // [9]
+  BedjetMode mode : 8;  ///< BedJet operating mode.
+
+  // [10]
+  uint8_t fan_step : 8;  ///< BedJet fan speed; value is in the 0-19 range, representing 5% increments (5%-100%): `5 + 5
+                         ///< * fan_step`
+  uint8_t max_hrs : 8;   ///< Max hours of mode runtime
+  uint8_t max_mins : 8;  ///< Max minutes of mode runtime
+  uint8_t min_temp_step : 8;  ///< Min temp allowed in mode. See #actual_temp_step.
+  uint8_t max_temp_step : 8;  ///< Max temp allowed in mode. See #actual_temp_step.
+
+  // [15-16]
+  uint16_t turbo_time : 16;  ///< Time remaining in BedjetMode::MODE_TURBO.
+
+  // [17]
+  uint8_t ambient_temp_step : 8;  ///< Current ambient air temp. This is the coldest air the BedJet can blow. See
+                                  ///< #actual_temp_step.
+  uint8_t shutdown_reason : 8;    ///< The reason for the last device shutdown.
+
+  // [19-25]; the initial partial packet cuts off here after [19]
+  // Skip 7 bytes?
+  uint32_t _skip_1_ : 32;  // Unknown 19-22 = 0x01810112
+
+  uint16_t _skip_2_ : 16;  // Unknown 23-24 = 0x1310
+  uint8_t _skip_3_ : 8;    // Unknown 25 = 0x00
+
+  // [26]
+  //   0x18(24) = "Connection test has completed OK"
+  //   0x1a(26) = "Firmware update is not needed"
+  uint8_t update_phase : 8;  ///< The current status/phase of a firmware update.
+
+  // [27]
+  // FIXME: cannot nest packed struct of matching length here?
+  /* BedjetFlags */ uint8_t flags : 8;  /// See BedjetFlags for the packed byte flags.
+  // [28-31]; 20+11 bytes
+  uint32_t _skip_4_ : 32;  // Unknown
+
+} __attribute__((packed));
+
+/** This class is responsible for encoding command packets and decoding status packets.
+ *
+ * Status Packets
+ * ==============
+ * The BedJet protocol depends on registering for notifications on the esphome::BedJet::BEDJET_SERVICE_UUID
+ * characteristic. If the BedJet is on, it will send rapid updates as notifications. If it is off,
+ * it generally will not notify of any status.
+ *
+ * As the BedJet V3's BedjetStatusPacket exceeds the buffer size allowed for BLE notification packets,
+ * the notification packet will contain `BedjetStatusPacket::is_partial == 1`. When that happens, an additional
+ * read of the esphome::BedJet::BEDJET_SERVICE_UUID characteristic will contain the second portion of the
+ * full status packet.
+ *
+ * Command Packets
+ * ===============
+ * This class supports encoding a number of BedjetPacket commands:
+ * - Button press
+ *   This simulates a press of one of the BedjetButton values.
+ *   - BedjetPacket#command = BedjetCommand::CMD_BUTTON
+ *   - BedjetPacket#data [0] contains the BedjetButton value
+ * - Set target temp
+ *   This sets the BedJet's target temp to a concrete temperature value.
+ *   - BedjetPacket#command = BedjetCommand::CMD_SET_TEMP
+ *   - BedjetPacket#data [0] contains the BedJet temp value; see BedjetStatusPacket#actual_temp_step
+ * - Set fan speed
+ *   This sets the BedJet fan speed.
+ *   - BedjetPacket#command = BedjetCommand::CMD_SET_FAN
+ *   - BedjetPacket#data [0] contains the BedJet fan step in the range 0-19.
+ * - Set current time
+ *   The BedJet needs to have its clock set properly in order to run the biorhythm programs, which might
+ *   contain time-of-day based step rules.
+ *   - BedjetPacket#command = BedjetCommand::CMD_SET_TIME
+ *   - BedjetPacket#data [0] is hours, [1] is minutes
+ */
+class BedjetCodec {
+ public:
+  BedjetPacket *get_button_request(BedjetButton button);
+  BedjetPacket *get_set_target_temp_request(float temperature);
+  BedjetPacket *get_set_fan_speed_request(uint8_t fan_step);
+  BedjetPacket *get_set_time_request(uint8_t hour, uint8_t minute);
+
+  bool decode_notify(const uint8_t *data, uint16_t length);
+  void decode_extra(const uint8_t *data, uint16_t length);
+
+  inline bool has_status() { return this->status_packet_.has_value(); }
+  const optional<BedjetStatusPacket> &get_status_packet() const { return this->status_packet_; }
+  void clear_status() { this->status_packet_.reset(); }
+
+ protected:
+  BedjetPacket *clean_packet_();
+
+  uint8_t last_buffer_size_ = 0;
+
+  BedjetPacket packet_;
+
+  optional<BedjetStatusPacket> status_packet_;
+  BedjetStatusPacket buf_;
+};
+
+}  // namespace bedjet
+}  // namespace esphome

esphome/components/bedjet/bedjet_const.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <set>
+
+namespace esphome {
+namespace bedjet {
+
+static const char *const TAG = "bedjet";
+
+enum BedjetMode : uint8_t {
+  /// BedJet is Off
+  MODE_STANDBY = 0,
+  /// BedJet is in Heat mode (limited to 4 hours)
+  MODE_HEAT = 1,
+  /// BedJet is in Turbo mode (high heat, limited time)
+  MODE_TURBO = 2,
+  /// BedJet is in Extended Heat mode (limited to 10 hours)
+  MODE_EXTHT = 3,
+  /// BedJet is in Cool mode (actually "Fan only" mode)
+  MODE_COOL = 4,
+  /// BedJet is in Dry mode (high speed, no heat)
+  MODE_DRY = 5,
+  /// BedJet is in "wait" mode, a step during a biorhythm program
+  MODE_WAIT = 6,
+};
+
+/** Optional heating strategies to use for climate::CLIMATE_MODE_HEAT. */
+enum BedjetHeatMode {
+  /// HVACMode.HEAT is handled using BTN_HEAT (default)
+  HEAT_MODE_HEAT,
+  /// HVACMode.HEAT is handled using BTN_EXTHT
+  HEAT_MODE_EXTENDED,
+};
+
+enum BedjetButton : uint8_t {
+  /// Turn BedJet off
+  BTN_OFF = 0x1,
+  /// Enter Cool mode (fan only)
+  BTN_COOL = 0x2,
+  /// Enter Heat mode (limited to 4 hours)
+  BTN_HEAT = 0x3,
+  /// Enter Turbo mode (high heat, limited to 10 minutes)
+  BTN_TURBO = 0x4,
+  /// Enter Dry mode (high speed, no heat)
+  BTN_DRY = 0x5,
+  /// Enter Extended Heat mode (limited to 10 hours)
+  BTN_EXTHT = 0x6,
+
+  /// Start the M1 biorhythm/preset program
+  BTN_M1 = 0x20,
+  /// Start the M2 biorhythm/preset program
+  BTN_M2 = 0x21,
+  /// Start the M3 biorhythm/preset program
+  BTN_M3 = 0x22,
+
+  /* These are "MAGIC" buttons */
+
+  /// Turn debug mode on/off
+  MAGIC_DEBUG_ON = 0x40,
+  MAGIC_DEBUG_OFF = 0x41,
+  /// Perform a connection test.
+  MAGIC_CONNTEST = 0x42,
+  /// Request a firmware update. This will also restart the Bedjet.
+  MAGIC_UPDATE = 0x43,
+};
+
+enum BedjetCommand : uint8_t {
+  CMD_BUTTON = 0x1,
+  CMD_SET_TEMP = 0x3,
+  CMD_STATUS = 0x6,
+  CMD_SET_FAN = 0x7,
+  CMD_SET_TIME = 0x8,
+};
+
+#define BEDJET_FAN_STEP_NAMES_ \
+  { \
+    "5%", "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%", "65%", "70%", "75%", "80%", \
+        "85%", "90%", "95%", "100%" \
+  }
+
+static const char *const BEDJET_FAN_STEP_NAMES[20] = BEDJET_FAN_STEP_NAMES_;
+static const std::string BEDJET_FAN_STEP_NAME_STRINGS[20] = BEDJET_FAN_STEP_NAMES_;
+static const std::set<std::string> BEDJET_FAN_STEP_NAMES_SET BEDJET_FAN_STEP_NAMES_;
+
+}  // namespace bedjet
+}  // namespace esphome

esphome/components/bedjet/climate.py

@@ -0,0 +1,52 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate, ble_client, time
+from esphome.const import (
+    CONF_HEAT_MODE,
+    CONF_ID,
+    CONF_RECEIVE_TIMEOUT,
+    CONF_TIME_ID,
+)
+
+CODEOWNERS = ["@jhansche"]
+DEPENDENCIES = ["ble_client"]
+
+bedjet_ns = cg.esphome_ns.namespace("bedjet")
+Bedjet = bedjet_ns.class_(
+    "Bedjet", climate.Climate, ble_client.BLEClientNode, cg.PollingComponent
+)
+BedjetHeatMode = bedjet_ns.enum("BedjetHeatMode")
+BEDJET_HEAT_MODES = {
+    "heat": BedjetHeatMode.HEAT_MODE_HEAT,
+    "extended": BedjetHeatMode.HEAT_MODE_EXTENDED,
+}
+
+CONFIG_SCHEMA = (
+    climate.CLIMATE_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(Bedjet),
+            cv.Optional(CONF_HEAT_MODE, default="heat"): cv.enum(
+                BEDJET_HEAT_MODES, lower=True
+            ),
+            cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
+            cv.Optional(
+                CONF_RECEIVE_TIMEOUT, default="0s"
+            ): cv.positive_time_period_milliseconds,
+        }
+    )
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+    .extend(cv.polling_component_schema("30s"))
+)
+
+
+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_heating_mode(config[CONF_HEAT_MODE]))
+    if CONF_TIME_ID in config:
+        time_ = await cg.get_variable(config[CONF_TIME_ID])
+        cg.add(var.set_time_id(time_))
+    if CONF_RECEIVE_TIMEOUT in config:
+        cg.add(var.set_status_timeout(config[CONF_RECEIVE_TIMEOUT]))

esphome/components/bh1750/bh1750.cpp

@@ -4,23 +4,114 @@
 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
 static const uint8_t BH1750_COMMAND_MT_REG_LO = 0b01100000;  // last 5 bits
+static const uint8_t BH1750_COMMAND_ONE_TIME_L = 0b00100011;
+static const uint8_t BH1750_COMMAND_ONE_TIME_H = 0b00100000;
+static const uint8_t BH1750_COMMAND_ONE_TIME_H2 = 0b00100001;
+
+/*
+bh1750 properties:
+
+L-resolution mode:
+- resolution 4lx (@ mtreg=69)
+- measurement time: typ=16ms, max=24ms, scaled by MTreg value divided by 69
+- formula: counts / 1.2 * (69 / MTreg) lx
+H-resolution mode:
+- resolution 1lx (@ mtreg=69)
+- measurement time: typ=120ms, max=180ms, scaled by MTreg value divided by 69
+- formula: counts / 1.2 * (69 / MTreg) lx
+H-resolution mode2:
+- resolution 0.5lx (@ mtreg=69)
+- measurement time: typ=120ms, max=180ms, scaled by MTreg value divided by 69
+- formula: counts / 1.2 * (69 / MTreg) / 2 lx
+
+MTreg:
+- min=31, default=69, max=254
+
+-> only reason to use l-resolution is faster, but offers no higher range
+-> below ~7000lx, makes sense to use H-resolution2 @ MTreg=254
+-> try to maximize MTreg to get lowest noise level
+*/
 
 void BH1750Sensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up BH1750 '%s'...", this->name_.c_str());
-  if (!this->write_bytes(BH1750_COMMAND_POWER_ON, nullptr, 0)) {
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
     this->mark_failed();
     return;
   }
+}
 
-  uint8_t mtreg_hi = (this->measurement_time_ >> 5) & 0b111;
-  uint8_t mtreg_lo = (this->measurement_time_ >> 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);
+void BH1750Sensor::read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Turning on BH1750 failed");
+    f(NAN);
+    return;
+  }
+
+  if (active_mtreg_ != mtreg) {
+    // set mtreg
+    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> 5) & 0b111);
+    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> 0) & 0b11111);
+    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Setting measurement time for BH1750 failed");
+      active_mtreg_ = 0;
+      f(NAN);
+      return;
+    }
+    active_mtreg_ = mtreg;
+  }
+
+  uint8_t cmd;
+  uint16_t meas_time;
+  switch (mode) {
+    case BH1750_MODE_L:
+      cmd = BH1750_COMMAND_ONE_TIME_L;
+      meas_time = 24 * mtreg / 69;
+      break;
+    case BH1750_MODE_H:
+      cmd = BH1750_COMMAND_ONE_TIME_H;
+      meas_time = 180 * mtreg / 69;
+      break;
+    case BH1750_MODE_H2:
+      cmd = BH1750_COMMAND_ONE_TIME_H2;
+      meas_time = 180 * mtreg / 69;
+      break;
+    default:
+      f(NAN);
+      return;
+  }
+  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Starting measurement for BH1750 failed");
+    f(NAN);
+    return;
+  }
+
+  // probably not needed, but adjust for rounding
+  meas_time++;
+
+  this->set_timeout("read", meas_time, [this, mode, mtreg, f]() {
+    uint16_t raw_value;
+    if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Reading BH1750 data failed");
+      f(NAN);
+      return;
+    }
+    raw_value = i2c::i2ctohs(raw_value);
+
+    float lx = float(raw_value) / 1.2f;
+    lx *= 69.0f / mtreg;
+    if (mode == BH1750_MODE_H2)
+      lx /= 2.0f;
+
+    f(lx);
+  });
 }
 
 void BH1750Sensor::dump_config() {
@@ -30,60 +121,49 @@ void BH1750Sensor::dump_config() {
     ESP_LOGE(TAG, "Communication with BH1750 failed!");
   }
 
-  const char *resolution_s;
-  switch (this->resolution_) {
-    case BH1750_RESOLUTION_0P5_LX:
-      resolution_s = "0.5";
-      break;
-    case BH1750_RESOLUTION_1P0_LX:
-      resolution_s = "1";
-      break;
-    case BH1750_RESOLUTION_4P0_LX:
-      resolution_s = "4";
-      break;
-    default:
-      resolution_s = "Unknown";
-      break;
-  }
-  ESP_LOGCONFIG(TAG, "  Resolution: %s", resolution_s);
   LOG_UPDATE_INTERVAL(this);
 }
 
 void BH1750Sensor::update() {
-  if (!this->write_bytes(this->resolution_, nullptr, 0))
-    return;
+  // first do a quick measurement in L-mode with full range
+  // to find right range
+  this->read_lx_(BH1750_MODE_L, 31, [this](float val) {
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
+      return;
+    }
 
-  uint32_t wait = 0;
-  // use max conversion times
-  switch (this->resolution_) {
-    case BH1750_RESOLUTION_0P5_LX:
-    case BH1750_RESOLUTION_1P0_LX:
-      wait = 180;
-      break;
-    case BH1750_RESOLUTION_4P0_LX:
-      wait = 24;
-      break;
-  }
+    BH1750Mode use_mode;
+    uint8_t use_mtreg;
+    if (val <= 7000) {
+      use_mode = BH1750_MODE_H2;
+      use_mtreg = 254;
+    } else {
+      use_mode = BH1750_MODE_H;
+      // lx = counts / 1.2 * (69 / mtreg)
+      // -> mtreg = counts / 1.2 * (69 / lx)
+      // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
+      // -> mtreg = 50000*(10/12)*(69/lx)
+      int ideal_mtreg = 50000 * 10 * 69 / (12 * (int) val);
+      use_mtreg = std::min(254, std::max(31, ideal_mtreg));
+    }
+    ESP_LOGV(TAG, "L result: %f -> Calculated mode=%d, mtreg=%d", val, (int) use_mode, use_mtreg);
 
-  this->set_timeout("illuminance", wait, [this]() { this->read_data_(); });
+    this->read_lx_(use_mode, use_mtreg, [this](float val) {
+      if (std::isnan(val)) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        return;
+      }
+      ESP_LOGD(TAG, "'%s': Got illuminance=%.1flx", this->get_name().c_str(), val);
+      this->status_clear_warning();
+      this->publish_state(val);
+    });
+  });
 }
 
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
-void BH1750Sensor::read_data_() {
-  uint16_t raw_value;
-  if (!this->parent_->raw_receive_16(this->address_, &raw_value, 1)) {
-    this->status_set_warning();
-    return;
-  }
-
-  float lx = float(raw_value) / 1.2f;
-  lx *= 69.0f / this->measurement_time_;
-  ESP_LOGD(TAG, "'%s': Got illuminance=%.1flx", this->get_name().c_str(), lx);
-  this->publish_state(lx);
-  this->status_clear_warning();
-}
-
-void BH1750Sensor::set_resolution(BH1750Resolution resolution) { this->resolution_ = resolution; }
 
 }  // namespace bh1750
 }  // namespace esphome

esphome/components/bh1750/bh1750.h

@@ -7,29 +7,15 @@
 namespace esphome {
 namespace bh1750 {
 
-/// Enum listing all resolutions that can be used with the BH1750
-enum BH1750Resolution {
-  BH1750_RESOLUTION_4P0_LX = 0b00100011,  // one-time low resolution mode
-  BH1750_RESOLUTION_1P0_LX = 0b00100000,  // one-time high resolution mode 1
-  BH1750_RESOLUTION_0P5_LX = 0b00100001,  // one-time high resolution mode 2
+enum BH1750Mode {
+  BH1750_MODE_L,
+  BH1750_MODE_H,
+  BH1750_MODE_H2,
 };
 
 /// This class implements support for the i2c-based BH1750 ambient light sensor.
 class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c::I2CDevice {
  public:
-  /** Set the resolution of this sensor.
-   *
-   * Possible values are:
-   *
-   *  - `BH1750_RESOLUTION_4P0_LX`
-   *  - `BH1750_RESOLUTION_1P0_LX`
-   *  - `BH1750_RESOLUTION_0P5_LX` (default)
-   *
-   * @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; }
-
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
   void setup() override;
@@ -38,10 +24,9 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   float get_setup_priority() const override;
 
  protected:
-  void read_data_();
+  void read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f);
 
-  BH1750Resolution resolution_{BH1750_RESOLUTION_0P5_LX};
-  uint8_t measurement_time_;
+  uint8_t active_mtreg_{0};
 };
 
 }  // namespace bh1750

esphome/components/bh1750/sensor.py

@@ -1,33 +1,45 @@
 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 (
+    DEVICE_CLASS_ILLUMINANCE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_LUX,
+)
 
-DEPENDENCIES = ['i2c']
+DEPENDENCIES = ["i2c"]
+CODEOWNERS = ["@OttoWinter"]
 
-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,
-}
+bh1750_ns = cg.esphome_ns.namespace("bh1750")
 
-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))
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        BH1750Sensor,
+        unit_of_measurement=UNIT_LUX,
+        accuracy_decimals=1,
+        device_class=DEVICE_CLASS_ILLUMINANCE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.Optional("resolution"): cv.invalid(
+                "The 'resolution' option has been removed. The optimal value is now dynamically calculated."
+            ),
+            cv.Optional("measurement_duration"): cv.invalid(
+                "The 'measurement_duration' option has been removed. The optimal value is now dynamically calculated."
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x23))
+)
 
 
-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)
-
-    cg.add(var.set_resolution(config[CONF_RESOLUTION]))
-    cg.add(var.set_measurement_time(config[CONF_MEASUREMENT_TIME]))
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

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,38 @@
 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", fan.Fan, 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)
+    await fan.register_fan(var, config)
 
-    fan_ = yield 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,58 +4,37 @@
 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());
-  if (this->fan_->get_traits().supports_oscillation()) {
-    ESP_LOGCONFIG(TAG, "  Oscillation: YES");
-  }
-  if (this->fan_->get_traits().supports_direction()) {
-    ESP_LOGCONFIG(TAG, "  Direction: YES");
-  }
-}
 void BinaryFan::setup() {
-  auto traits = fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr);
-  this->fan_->set_traits(traits);
-  this->fan_->add_on_state_callback([this]() { this->next_update_ = true; });
-}
-void BinaryFan::loop() {
-  if (!this->next_update_) {
-    return;
-  }
-  this->next_update_ = false;
-
-  {
-    bool enable = this->fan_->state;
-    if (enable)
-      this->output_->turn_on();
-    else
-      this->output_->turn_off();
-    ESP_LOGD(TAG, "Setting binary state: %s", ONOFF(enable));
-  }
-
-  if (this->oscillating_ != nullptr) {
-    bool enable = this->fan_->oscillating;
-    if (enable) {
-      this->oscillating_->turn_on();
-    } else {
-      this->oscillating_->turn_off();
-    }
-    ESP_LOGD(TAG, "Setting oscillation: %s", ONOFF(enable));
-  }
-
-  if (this->direction_ != nullptr) {
-    bool enable = this->fan_->direction == fan::FAN_DIRECTION_REVERSE;
-    if (enable) {
-      this->direction_->turn_on();
-    } else {
-      this->direction_->turn_off();
-    }
-    ESP_LOGD(TAG, "Setting reverse direction: %s", ONOFF(enable));
+  auto restore = this->restore_state_();
+  if (restore.has_value()) {
+    restore->apply(*this);
+    this->write_state_();
   }
 }
-float BinaryFan::get_setup_priority() const { return setup_priority::DATA; }
+void BinaryFan::dump_config() { LOG_FAN("", "Binary Fan", this); }
+fan::FanTraits BinaryFan::get_traits() {
+  return fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr, 0);
+}
+void BinaryFan::control(const fan::FanCall &call) {
+  if (call.get_state().has_value())
+    this->state = *call.get_state();
+  if (call.get_oscillating().has_value())
+    this->oscillating = *call.get_oscillating();
+  if (call.get_direction().has_value())
+    this->direction = *call.get_direction();
+
+  this->write_state_();
+  this->publish_state();
+}
+void BinaryFan::write_state_() {
+  this->output_->set_state(this->state);
+  if (this->oscillating_ != nullptr)
+    this->oscillating_->set_state(this->oscillating);
+  if (this->direction_ != nullptr)
+    this->direction_->set_state(this->direction == fan::FanDirection::REVERSE);
+}
 
 }  // namespace binary
 }  // namespace esphome

esphome/components/binary/fan/binary_fan.h

@@ -2,28 +2,29 @@
 
 #include "esphome/core/component.h"
 #include "esphome/components/output/binary_output.h"
-#include "esphome/components/fan/fan_state.h"
+#include "esphome/components/fan/fan.h"
 
 namespace esphome {
 namespace binary {
 
-class BinaryFan : public Component {
+class BinaryFan : public Component, public fan::Fan {
  public:
-  void set_fan(fan::FanState *fan) { fan_ = fan; }
-  void set_output(output::BinaryOutput *output) { output_ = output; }
   void setup() override;
-  void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
+
+  void set_output(output::BinaryOutput *output) { this->output_ = output; }
   void set_oscillating(output::BinaryOutput *oscillating) { this->oscillating_ = oscillating; }
   void set_direction(output::BinaryOutput *direction) { this->direction_ = direction; }
 
+  fan::FanTraits get_traits() override;
+
  protected:
-  fan::FanState *fan_;
+  void control(const fan::FanCall &call) override;
+  void write_state_();
+
   output::BinaryOutput *output_;
   output::BinaryOutput *oscillating_{nullptr};
   output::BinaryOutput *direction_{nullptr};
-  bool next_update_{true};
 };
 
 }  // namespace binary

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

@@ -1,132 +1,268 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
+from esphome.cpp_generator import MockObjClass
+from esphome.cpp_helpers import setup_entity
 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_ENTITY_CATEGORY,
+    CONF_FILTERS,
+    CONF_ICON,
+    CONF_ID,
+    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_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_RUNNING,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_TAMPER,
+    DEVICE_CLASS_UPDATE,
+    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_RUNNING,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_TAMPER,
+    DEVICE_CLASS_UPDATE,
+    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.EntityBase)
+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(
+            f"Multi click timing grammar consists of exactly 5 words, not {len(parts)}"
+        )
     try:
         state = cv.boolean(parts[0])
     except cv.Invalid:
-        raise cv.Invalid("First word must either be ON or OFF, not {}".format(parts[0]))
+        # pylint: disable=raise-missing-from
+        raise cv.Invalid(f"First word must either be ON or OFF, not {parts[0]}")
 
-    if parts[1] != 'for':
-        raise cv.Invalid("Second word must be 'for', got {}".format(parts[1]))
+    if parts[1] != "for":
+        raise cv.Invalid(f"Second word must be 'for', got {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(
+                f"Third word after at must either be 'least' or 'most', got {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 +278,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 +298,13 @@ 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(
+                f"Timings must have alternating state. Indices {i} and {i + 1} have the same state {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(
+                f"Max length ({max_length}) must be larger than min length ({min_length})."
+            )
 
         state = new_state
         tim = {
@@ -179,140 +317,196 @@ def validate_multi_click_timing(value):
     return timings
 
 
-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."
-    ),
-})
+validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 
-@coroutine
-def setup_binary_sensor_core_(var, config):
-    cg.add(var.set_name(config[CONF_NAME]))
-    if CONF_INTERNAL in config:
-        cg.add(var.set_internal(config[CONF_INTERNAL]))
+BINARY_SENSOR_SCHEMA = cv.ENTITY_BASE_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): validate_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),
+            }
+        ),
+    }
+)
+
+_UNDEF = object()
+
+
+def binary_sensor_schema(
+    class_: MockObjClass = _UNDEF,
+    *,
+    icon: str = _UNDEF,
+    entity_category: str = _UNDEF,
+    device_class: str = _UNDEF,
+) -> cv.Schema:
+    schema = BINARY_SENSOR_SCHEMA
+    if class_ is not _UNDEF:
+        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
+    if icon is not _UNDEF:
+        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
+    if entity_category is not _UNDEF:
+        schema = schema.extend(
+            {
+                cv.Optional(
+                    CONF_ENTITY_CATEGORY, default=entity_category
+                ): cv.entity_category
+            }
+        )
+    if device_class is not _UNDEF:
+        schema = schema.extend(
+            {
+                cv.Optional(
+                    CONF_DEVICE_CLASS, default=device_class
+                ): validate_device_class
+            }
+        )
+    return schema
+
+
+async def setup_binary_sensor_core_(var, config):
+    await setup_entity(var, config)
+
     if CONF_DEVICE_CLASS in config:
         cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
     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):
-    var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
-    yield register_binary_sensor(var, config)
-    yield var
+async def new_binary_sensor(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    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,7 +1,10 @@
 #pragma once
 
+#include <utility>
+
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/hal.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
 namespace esphome {
@@ -87,8 +90,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));
@@ -42,13 +42,15 @@ void BinarySensor::send_state_internal(bool state, bool is_initial) {
   }
 }
 std::string BinarySensor::device_class() { return ""; }
-BinarySensor::BinarySensor(const std::string &name) : Nameable(name), state(false) {}
-BinarySensor::BinarySensor() : BinarySensor("") {}
+BinarySensor::BinarySensor() : state(false) {}
 void BinarySensor::set_device_class(const std::string &device_class) { this->device_class_ = device_class; }
 std::string BinarySensor::get_device_class() {
   if (this->device_class_.has_value())
     return *this->device_class_;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return this->device_class();
+#pragma GCC diagnostic pop
 }
 void BinarySensor::add_filter(Filter *filter) {
   filter->parent_ = this;
@@ -61,13 +63,12 @@ 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);
   }
 }
 bool BinarySensor::has_state() const { return this->has_state_; }
-uint32_t BinarySensor::hash_base() { return 1210250844UL; }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
 }  // namespace binary_sensor

esphome/components/binary_sensor/binary_sensor.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/filter.h"
 
@@ -9,10 +10,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, LOG_STR_LITERAL(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()); \
     } \
   }
 
@@ -22,14 +23,9 @@ namespace binary_sensor {
  * The sub classes should notify the front-end of new states via the publish_state() method which
  * handles inverted inputs for you.
  */
-class BinarySensor : public Nameable {
+class BinarySensor : public EntityBase {
  public:
   explicit BinarySensor();
-  /** Construct a binary sensor with the specified name
-   *
-   * @param name Name of this binary sensor.
-   */
-  explicit BinarySensor(const std::string &name);
 
   /** Add a callback to be notified of state changes.
    *
@@ -60,7 +56,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)
@@ -73,12 +69,13 @@ class BinarySensor : public Nameable {
 
   // ========== OVERRIDE METHODS ==========
   // (You'll only need this when creating your own custom binary sensor)
-  /// Get the default device class for this sensor, or empty string for no default.
+  /** Override this to set the default device class.
+   *
+   * @deprecated This method is deprecated, set the property during config validation instead. (2022.1)
+   */
   virtual std::string device_class();
 
  protected:
-  uint32_t hash_base() override;
-
   CallbackManager<void(bool)> state_callback_{};
   optional<std::string> device_class_{};  ///< Stores the override of the device class
   Filter *filter_list_{nullptr};

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,22 @@ 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_CHANNELS,
+    CONF_VALUE,
+    CONF_TYPE,
+    ICON_CHECK_CIRCLE_OUTLINE,
+    CONF_BINARY_SENSOR,
+    CONF_GROUP,
+)
 
-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 +28,31 @@ 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(
+            BinarySensorMap,
+            icon=ICON_CHECK_CIRCLE_OUTLINE,
+            accuracy_decimals=0,
+        ).extend(
+            {
+                cv.Required(CONF_CHANNELS): cv.All(
+                    cv.ensure_list(entry), cv.Length(min=1)
+                ),
+            }
+        ),
+    },
+    lower=True,
+)
 
 
-def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield sensor.register_sensor(var, config)
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(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]))