Merge pull request #1923 from esphome/bump-1.19.0

1.19.0

.clang-tidy

@@ -4,14 +4,35 @@ Checks: >-
   -abseil-*,
   -android-*,
   -boost-*,
+  -bugprone-branch-clone,
   -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
+  -bugprone-reserved-identifier,
+  -bugprone-signed-char-misuse,
+  -bugprone-suspicious-include,
+  -bugprone-too-small-loop-variable,
+  -bugprone-unhandled-self-assignment,
+  -cert-dcl37-c,
   -cert-dcl50-cpp,
+  -cert-dcl51-cpp,
   -cert-err58-cpp,
+  -cert-oop54-cpp,
+  -cert-oop57-cpp,
+  -cert-str34-c,
   -clang-analyzer-core.CallAndMessage,
+  -clang-analyzer-optin.*,
   -clang-analyzer-osx.*,
   -clang-analyzer-security.*,
+  -clang-diagnostic-shadow-field,
+  -cppcoreguidelines-avoid-c-arrays,
   -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
   -cppcoreguidelines-c-copy-assignment-signature,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-constant-array-index,
@@ -37,10 +58,16 @@ Checks: >-
   -google-runtime-int,
   -google-runtime-references,
   -hicpp-*,
+  -llvm-else-after-return,
   -llvm-header-guard,
   -llvm-include-order,
+  -llvm-qualified-auto,
+  -llvmlibc-*,
+  -misc-non-private-member-variables-in-classes,
+  -misc-no-recursion,
   -misc-unconventional-assign-operator,
   -misc-unused-parameters,
+  -modernize-avoid-c-arrays,
   -modernize-deprecated-headers,
   -modernize-pass-by-value,
   -modernize-pass-by-value,
@@ -48,14 +75,25 @@ Checks: >-
   -modernize-use-auto,
   -modernize-use-default-member-init,
   -modernize-use-equals-default,
+  -modernize-use-trailing-return-type,
   -mpi-*,
   -objc-*,
   -performance-unnecessary-value-param,
   -readability-braces-around-statements,
+  -readability-const-return-type,
+  -readability-convert-member-functions-to-static,
   -readability-else-after-return,
   -readability-implicit-bool-conversion,
+  -readability-isolate-declaration,
+  -readability-magic-numbers,
+  -readability-make-member-function-const,
   -readability-named-parameter,
+  -readability-qualified-auto,
+  -readability-redundant-access-specifiers,
   -readability-redundant-member-init,
+  -readability-redundant-string-init,
+  -readability-uppercase-literal-suffix,
+  -readability-use-anyofallof,
   -warnings-as-errors,
   -zircon-*
 WarningsAsErrors: '*'

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+omit = esphome/components/*

.devcontainer/devcontainer.json

@@ -0,0 +1,32 @@
+{
+  "name": "ESPHome Dev",
+  "context": "..",
+  "dockerFile": "../docker/Dockerfile.dev",
+  "postCreateCommand": "mkdir -p config && pip3 install -e .",
+  "runArgs": ["--privileged", "-e", "ESPHOME_DASHBOARD_USE_PING=1"],
+  "appPort": 6052,
+  "extensions": [
+    "ms-python.python",
+    "visualstudioexptteam.vscodeintellicode",
+    "redhat.vscode-yaml"
+  ],
+  "settings": {
+    "python.pythonPath": "/usr/local/bin/python",
+    "python.linting.pylintEnabled": true,
+    "python.linting.enabled": true,
+    "python.formatting.provider": "black",
+    "editor.formatOnPaste": false,
+    "editor.formatOnSave": true,
+    "editor.formatOnType": true,
+    "files.trimTrailingWhitespace": true,
+    "terminal.integrated.shell.linux": "/bin/bash",
+    "yaml.customTags": [
+      "!secret scalar",
+      "!lambda scalar",
+      "!include_dir_named scalar",
+      "!include_dir_list scalar",
+      "!include_dir_merge_list scalar",
+      "!include_dir_merge_named scalar"
+    ]
+  }
+}

.editorconfig

@@ -25,3 +25,4 @@ indent_size = 2
 [*.{yaml,yml}]
 indent_style = space
 indent_size = 2
+quote_type = single

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+custom: https://www.nabucasa.com

.github/ISSUE_TEMPLATE/config.yml

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

.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    ignore:
+      # Hypotehsis is only used for testing and is updated quite often
+      - dependency-name: hypothesis

.github/lock.yml

@@ -0,0 +1,36 @@
+# 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

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,55 @@
+name: CI for docker images
+
+# Only run when docker paths change
+on:
+  push:
+    branches: [dev, beta, master]
+    paths:
+      - 'docker/**'
+      - '.github/workflows/**'
+
+  pull_request:
+    paths:
+      - 'docker/**'
+      - '.github/workflows/**'
+
+jobs:
+  check-docker:
+    name: Build docker containers
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [amd64, armv7, aarch64]
+        build_type: ["hassio", "docker"]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up env variables
+        run: |
+          base_version="3.4.0"
+
+          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
+            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile.hassio"
+          else
+            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile"
+          fi
+
+          echo "BUILD_FROM=${build_from}" >> $GITHUB_ENV
+          echo "BUILD_TO=${build_to}" >> $GITHUB_ENV
+          echo "DOCKERFILE=${dockerfile}" >> $GITHUB_ENV
+      - 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.2.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}" \
+            .

.github/workflows/ci.yml

@@ -0,0 +1,161 @@
+# 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]
+
+  pull_request:
+
+jobs:
+  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:1.1
+    steps:
+      - uses: actions/checkout@v2
+      # 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:1.1
+    # 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
+      # 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:
+      fail-fast: false
+      matrix:
+          test:
+          - test1
+          - test2
+          - test3
+          - test4
+          - test5
+    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 compile tests/${{ matrix.test }}.yaml
+
+  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

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

@@ -0,0 +1,42 @@
+name: Build and publish lint docker image
+
+# Only run when docker paths change
+on:
+  push:
+    branches: [dev]
+    paths:
+      - 'docker/Dockerfile.lint'
+      - 'requirements.txt'
+      - 'requirements_optional.txt'
+      - 'requirements_test.txt'
+      - 'platformio.ini'
+      - '.github/workflows/docker-lint-build.yml'
+
+jobs:
+  publish-docker-lint-iage:
+    name: Build docker containers
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set TAG
+        run: |
+          echo "TAG=1.1" >> $GITHUB_ENV
+      - name: Pull for cache
+        run: |
+          docker pull "esphome/esphome-lint:latest" || true
+      - name: Build
+        run: |
+          docker build \
+            --cache-from "esphome/esphome-lint:latest" \
+            --file "docker/Dockerfile.lint" \
+            --tag "esphome/esphome-lint:latest" \
+            --tag "esphome/esphome-lint:${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}"
+      - run: |
+          docker push "esphome/esphome-lint:${TAG}"
+          docker push "esphome/esphome-lint:latest"

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

@@ -0,0 +1,16 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "ci-custom",
+            "pattern": [
+                {
+                    "regexp": "^ERROR (.*):(\\d+):(\\d+) - (.*)$",
+                    "file": 1,
+                    "line": 2,
+                    "column": 3,
+                    "message": 4
+                }
+            ]
+        }
+    ]
+}

.github/workflows/matchers/clang-tidy.json

@@ -0,0 +1,17 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "clang-tidy",
+            "pattern": [
+                {
+                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(error):\\s+(.*) \\[([a-z0-9,\\-]+)\\]\\s*$",
+                    "file": 1,
+                    "line": 2,
+                    "column": 3,
+                    "severity": 4,
+                    "message": 5
+                }
+            ]
+        }
+    ]
+}

.github/workflows/matchers/gcc.json

@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "gcc",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+):(\\d+):\\s+(?:fatal\\s+)?(warning|error):\\s+(.*)$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "severity": 4,
+          "message": 5
+        }
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,28 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "flake8",
+      "severity": "error",
+      "pattern": [
+          {
+          "regexp": "^(.*):(\\d+) - ([EFCDNW]\\d{3}.*)$",
+          "file": 1,
+          "line": 2,
+          "message": 3
+          }
+      ]
+    },
+    {
+      "owner": "pylint",
+      "severity": "error",
+      "pattern": [
+        {
+          "regexp": "^(.*):(\\d+) - (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
+          "file": 1,
+          "line": 2,
+          "message": 3
+        }
+      ]
+    }
+  ]
+}

.github/workflows/matchers/python.json

@@ -0,0 +1,18 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "python",
+            "pattern": [
+                {
+                    "regexp": "^\\s*File\\s\\\"(.*)\\\",\\sline\\s(\\d+),\\sin\\s(.*)$",
+                    "file": 1,
+                    "line": 2
+                },
+                {
+                    "regexp": "^\\s*raise\\s(.*)\\(\\'(.*)\\'\\)$",
+                    "message": 2
+                }
+            ]
+        }
+    ]
+}

.github/workflows/release-dev.yml

@@ -0,0 +1,247 @@
+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:1.1
+    steps:
+      - uses: actions/checkout@v2
+      # 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:1.1
+    # 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
+      # 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:
+      fail-fast: false
+      matrix:
+          test:
+          - test1
+          - test2
+          - test3
+          - test4
+          - test5
+    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 compile tests/${{ matrix.test }}.yaml
+
+  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 "TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up env variables
+        run: |
+          base_version="3.4.0"
+
+          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
+            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile.hassio"
+          else
+            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile"
+          fi
+
+          echo "BUILD_FROM=${build_from}" >> $GITHUB_ENV
+          echo "BUILD_TO=${build_to}" >> $GITHUB_ENV
+          echo "DOCKERFILE=${dockerfile}" >> $GITHUB_ENV
+      - 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.2.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 "TAG=${TAG}" >> $GITHUB_ENV
+    - 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

@@ -0,0 +1,310 @@
+name: Publish Release
+
+on:
+  release:
+    types: [published]
+
+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:1.1
+    steps:
+      - uses: actions/checkout@v2
+      # 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:1.1
+    # 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
+      # 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:
+      fail-fast: false
+      matrix:
+          test:
+          - test1
+          - test2
+          - test3
+          - test4
+          - test5
+    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 compile tests/${{ matrix.test }}.yaml
+
+  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-pypi:
+    name: Build and publish to PyPi
+    if: github.repository == 'esphome/esphome'
+    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Python
+        uses: actions/setup-python@v1
+        with:
+          python-version: '3.x'
+      - name: Set up python environment
+        run: |
+          script/setup
+          pip install setuptools wheel twine
+      - name: Build
+        run: python setup.py sdist bdist_wheel
+      - name: Upload
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        run: twine upload dist/*
+
+  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]
+        build_type: ["hassio", "docker"]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set TAG
+        run: |
+          TAG="${GITHUB_REF#refs/tags/v}"
+          echo "TAG=${TAG}" >> $GITHUB_ENV
+      - name: Set up env variables
+        run: |
+          base_version="3.4.0"
+
+          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
+            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile.hassio"
+          else
+            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
+            build_to="esphome/esphome-${{ matrix.arch }}"
+            dockerfile="docker/Dockerfile"
+          fi
+
+          if [[ "${{ github.event.release.prerelease }}" == "true" ]]; then
+            cache_tag="beta"
+          else
+            cache_tag="latest"
+          fi
+
+          # Set env variables so these values don't need to be calculated again
+          echo "BUILD_FROM=${build_from}" >> $GITHUB_ENV
+          echo "BUILD_TO=${build_to}" >> $GITHUB_ENV
+          echo "DOCKERFILE=${dockerfile}" >> $GITHUB_ENV
+          echo "CACHE_TAG=${cache_tag}" >> $GITHUB_ENV
+      - name: Pull for cache
+        run: |
+          docker pull "${BUILD_TO}:${CACHE_TAG}" || true
+      - name: Register QEMU binfmt
+        run: docker run --rm --privileged multiarch/qemu-user-static:5.2.0-2 --reset -p yes
+      - run: |
+          docker build \
+            --build-arg "BUILD_FROM=${BUILD_FROM}" \
+            --build-arg "BUILD_VERSION=${TAG}" \
+            --tag "${BUILD_TO}:${TAG}" \
+            --cache-from "${BUILD_TO}:${CACHE_TAG}" \
+            --file "${DOCKERFILE}" \
+            .
+      - name: Log in to docker hub
+        env:
+          DOCKER_USER: ${{ secrets.DOCKER_USER }}
+          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
+        run: docker login -u "${DOCKER_USER}" -p "${DOCKER_PASSWORD}"
+      - run: docker push "${BUILD_TO}:${TAG}"
+
+      # Always publish to beta tag (also full releases)
+      - name: Publish docker beta tag
+        run: |
+          docker tag "${BUILD_TO}:${TAG}" "${BUILD_TO}:beta"
+          docker push "${BUILD_TO}:beta"
+
+      - if: ${{ !github.event.release.prerelease }}
+        name: Publish docker latest tag
+        run: |
+          docker tag "${BUILD_TO}:${TAG}" "${BUILD_TO}:latest"
+          docker push "${BUILD_TO}:latest"
+
+  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_REF#refs/tags/v}"
+        echo "TAG=${TAG}" >> $GITHUB_ENV
+    - 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}
+
+    - name: Publish docker beta tag
+      run: |
+        docker manifest create esphome/esphome:beta \
+          esphome/esphome-aarch64:${TAG} \
+          esphome/esphome-amd64:${TAG} \
+          esphome/esphome-armv7:${TAG}
+        docker manifest push esphome/esphome:beta
+
+    - name: Publish docker latest tag
+      if: ${{ !github.event.release.prerelease }}
+      run: |
+        docker manifest create esphome/esphome:latest \
+          esphome/esphome-aarch64:${TAG} \
+          esphome/esphome-amd64:${TAG} \
+          esphome/esphome-armv7:${TAG}
+        docker manifest push esphome/esphome:latest
+
+  deploy-hassio-repo:
+    if: github.repository == 'esphome/esphome'
+    runs-on: ubuntu-latest
+    needs: [deploy-docker]
+    steps:
+      - env:
+          TOKEN: ${{ secrets.DEPLOY_HASSIO_TOKEN }}
+        run: |
+          TAG="${GITHUB_REF#refs/tags/v}"
+          curl \
+            -u ":$TOKEN" \
+            -X POST \
+            -H "Accept: application/vnd.github.v3+json" \
+            https://api.github.com/repos/esphome/hassio/actions/workflows/bump-version.yml/dispatches \
+            -d "{\"ref\":\"master\",\"inputs\":{\"version\":\"$TAG\"}}"

.gitignore

@@ -10,6 +10,9 @@ __pycache__/
 *.sublime-project
 *.sublime-workspace
 
+# Intellij Idea
+.idea
+
 # Hide some OS X stuff
 .DS_Store
 .AppleDouble
@@ -48,8 +51,10 @@ htmlcov/
 .coverage
 .coverage.*
 .cache
+.esphome
 nosetests.xml
 coverage.xml
+cov.xml
 *.cover
 .hypothesis/
 .pytest_cache/
@@ -75,7 +80,9 @@ venv.bak/
 
 .pioenvs
 .piolibdeps
-.vscode
+.pio
+.vscode/
+!.vscode/tasks.json
 CMakeListsPrivate.txt
 CMakeLists.txt
 
@@ -93,6 +100,8 @@ CMakeLists.txt
 
 # CMake
 cmake-build-debug/
+cmake-build-livingroom8266/
+cmake-build-livingroom32/
 cmake-build-release/
 
 CMakeCache.txt
@@ -113,3 +122,4 @@ config/
 tests/build/
 tests/.esphome/
 /.temp-clang-tidy.cpp
+.pio/

.gitlab-ci.yml

@@ -1,346 +0,0 @@
----
-# Based on https://gitlab.com/hassio-addons/addon-node-red/blob/master/.gitlab-ci.yml
-variables:
-  DOCKER_DRIVER: overlay2
-  DOCKER_HOST: tcp://docker:2375/
-  BASE_VERSION: '1.5.1'
-  TZ: UTC
-
-stages:
-  - lint
-  - test
-  - deploy
-
-.lint: &lint
-  image: esphome/esphome-lint:latest
-  stage: lint
-  before_script:
-    - script/setup
-  tags:
-    - docker
-
-.test: &test
-  image: esphome/esphome-lint:latest
-  stage: test
-  before_script:
-    - script/setup
-  tags:
-    - docker
-
-.docker-base: &docker-base
-  image: esphome/esphome-base-builder
-  before_script:
-    - docker info
-    - docker login -u "$DOCKER_USER" -p "$DOCKER_PASSWORD"
-  script:
-    - docker run --rm --privileged hassioaddons/qemu-user-static:latest
-    - TAG="${CI_COMMIT_TAG#v}"
-    - TAG="${TAG:-${CI_COMMIT_SHA:0:7}}"
-    - echo "Tag ${TAG}"
-
-    - |
-      if [[ "${IS_HASSIO}" == "YES" ]]; then
-        BUILD_FROM=esphome/esphome-hassio-base-${BUILD_ARCH}:${BASE_VERSION}
-        BUILD_TO=esphome/esphome-hassio-${BUILD_ARCH}
-        DOCKERFILE=docker/Dockerfile.hassio
-      else
-        BUILD_FROM=esphome/esphome-base-${BUILD_ARCH}:${BASE_VERSION}
-        if [[ "${BUILD_ARCH}" == "amd64" ]]; then
-          BUILD_TO=esphome/esphome
-        else
-          BUILD_TO=esphome/esphome-${BUILD_ARCH}
-        fi
-        DOCKERFILE=docker/Dockerfile
-      fi
-
-    - |
-      docker build \
-        --build-arg "BUILD_FROM=${BUILD_FROM}" \
-        --build-arg "BUILD_VERSION=${TAG}" \
-        --tag "${BUILD_TO}:${TAG}" \
-        --file "${DOCKERFILE}" \
-        .
-    - |
-      if [[ "${RELEASE}" = "YES" ]]; then
-        echo "Pushing to ${BUILD_TO}:${TAG}"
-        docker push "${BUILD_TO}:${TAG}"
-      fi
-    - |
-      if [[ "${LATEST}" = "YES" ]]; then
-        echo "Pushing to :latest"
-        docker tag ${BUILD_TO}:${TAG} ${BUILD_TO}:latest
-        docker push ${BUILD_TO}:latest
-      fi
-    - |
-      if [[ "${BETA}" = "YES" ]]; then
-        echo "Pushing to :beta"
-        docker tag \
-          ${BUILD_TO}:${TAG} \
-          ${BUILD_TO}:beta
-        docker push ${BUILD_TO}:beta
-      fi
-    - |
-      if [[ "${DEV}" = "YES" ]]; then
-        echo "Pushing to :dev"
-        docker tag \
-          ${BUILD_TO}:${TAG} \
-          ${BUILD_TO}:dev
-        docker push ${BUILD_TO}:dev
-      fi
-  services:
-    - docker:dind
-  tags:
-    - docker
-  stage: deploy
-
-lint-custom:
-  <<: *lint
-  script:
-    - script/ci-custom.py
-
-lint-python:
-  <<: *lint
-  script:
-    - script/lint-python
-
-lint-tidy:
-  <<: *lint
-  script:
-    - pio init --ide atom
-    - |
-      if ! patch -R -p0 -s -f --dry-run <script/.neopixelbus.patch; then
-        patch -p0 < script/.neopixelbus.patch
-      fi
-    - script/clang-tidy --all-headers --fix
-    - script/ci-suggest-changes
-
-lint-format:
-  <<: *lint
-  script:
-    - script/clang-format -i
-    - script/ci-suggest-changes
-
-test1:
-  <<: *test
-  script:
-    - esphome tests/test1.yaml compile
-
-test2:
-  <<: *test
-  script:
-    - esphome tests/test2.yaml compile
-
-test3:
-  <<: *test
-  script:
-    - esphome tests/test3.yaml compile
-
-.deploy-pypi: &deploy-pypi
-  <<: *lint
-  stage: deploy
-  script:
-    - pip install twine wheel
-    - python setup.py sdist bdist_wheel
-    - twine upload dist/*
-
-deploy-release:pypi:
-  <<: *deploy-pypi
-  only:
-    - /^v\d+\.\d+\.\d+$/
-  except:
-    - /^(?!master).+@/
-
-deploy-beta:pypi:
-  <<: *deploy-pypi
-  only:
-    - /^v\d+\.\d+\.\d+b\d+$/
-  except:
-    - /^(?!rc).+@/
-
-.latest: &latest
-  <<: *docker-base
-  only:
-    - /^v([0-9\.]+)$/
-  except:
-    - branches
-
-.beta: &beta
-  <<: *docker-base
-  only:
-    - /^v([0-9\.]+b\d+)$/
-  except:
-    - branches
-
-.dev: &dev
-  <<: *docker-base
-  only:
-    - dev
-
-aarch64-beta-docker:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: aarch64
-    IS_HASSIO: "NO"
-    RELEASE: "YES"
-aarch64-beta-hassio:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: aarch64
-    IS_HASSIO: "YES"
-    RELEASE: "YES"
-aarch64-dev-docker:
-  <<: *dev
-  variables:
-    BUILD_ARCH: aarch64
-    DEV: "YES"
-    IS_HASSIO: "NO"
-aarch64-dev-hassio:
-  <<: *dev
-  variables:
-    BUILD_ARCH: aarch64
-    DEV: "YES"
-    IS_HASSIO: "YES"
-aarch64-latest-docker:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: aarch64
-    IS_HASSIO: "NO"
-    LATEST: "YES"
-    RELEASE: "YES"
-aarch64-latest-hassio:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: aarch64
-    IS_HASSIO: "YES"
-    LATEST: "YES"
-    RELEASE: "YES"
-amd64-beta-docker:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: amd64
-    IS_HASSIO: "NO"
-    RELEASE: "YES"
-amd64-beta-hassio:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: amd64
-    IS_HASSIO: "YES"
-    RELEASE: "YES"
-amd64-dev-docker:
-  <<: *dev
-  variables:
-    BUILD_ARCH: amd64
-    DEV: "YES"
-    IS_HASSIO: "NO"
-amd64-dev-hassio:
-  <<: *dev
-  variables:
-    BUILD_ARCH: amd64
-    DEV: "YES"
-    IS_HASSIO: "YES"
-amd64-latest-docker:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: amd64
-    IS_HASSIO: "NO"
-    LATEST: "YES"
-    RELEASE: "YES"
-amd64-latest-hassio:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: amd64
-    IS_HASSIO: "YES"
-    LATEST: "YES"
-    RELEASE: "YES"
-armv7-beta-docker:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: armv7
-    IS_HASSIO: "NO"
-    RELEASE: "YES"
-armv7-beta-hassio:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: armv7
-    IS_HASSIO: "YES"
-    RELEASE: "YES"
-armv7-dev-docker:
-  <<: *dev
-  variables:
-    BUILD_ARCH: armv7
-    DEV: "YES"
-    IS_HASSIO: "NO"
-armv7-dev-hassio:
-  <<: *dev
-  variables:
-    BUILD_ARCH: armv7
-    DEV: "YES"
-    IS_HASSIO: "YES"
-armv7-latest-docker:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: armv7
-    IS_HASSIO: "NO"
-    LATEST: "YES"
-    RELEASE: "YES"
-armv7-latest-hassio:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: armv7
-    IS_HASSIO: "YES"
-    LATEST: "YES"
-    RELEASE: "YES"
-i386-beta-docker:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: i386
-    IS_HASSIO: "NO"
-    RELEASE: "YES"
-i386-beta-hassio:
-  <<: *beta
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: i386
-    IS_HASSIO: "YES"
-    RELEASE: "YES"
-i386-dev-docker:
-  <<: *dev
-  variables:
-    BUILD_ARCH: i386
-    DEV: "YES"
-    IS_HASSIO: "NO"
-i386-dev-hassio:
-  <<: *dev
-  variables:
-    BUILD_ARCH: i386
-    DEV: "YES"
-    IS_HASSIO: "YES"
-i386-latest-docker:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: i386
-    IS_HASSIO: "NO"
-    LATEST: "YES"
-    RELEASE: "YES"
-i386-latest-hassio:
-  <<: *latest
-  variables:
-    BETA: "YES"
-    BUILD_ARCH: i386
-    IS_HASSIO: "YES"
-    LATEST: "YES"
-    RELEASE: "YES"

.gitpod.yml

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

.pre-commit-config.yaml

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

.travis.yml

@@ -1,57 +0,0 @@
-sudo: false
-language: python
-python: '2.7'
-install: script/setup
-cache:
-  directories:
-    - "~/.platformio"
-    - "$TRAVIS_BUILD_DIR/.piolibdeps"
-    - "$TRAVIS_BUILD_DIR/tests/build/test1/.piolibdeps"
-    - "$TRAVIS_BUILD_DIR/tests/build/test2/.piolibdeps"
-    - "$TRAVIS_BUILD_DIR/tests/build/test3/.piolibdeps"
-
-matrix:
-  fast_finish: true
-  include:
-    - python: "2.7"
-      env: TARGET=Lint2.7
-      script:
-        - script/ci-custom.py
-        - flake8 esphome
-        - pylint esphome
-    - python: "3.5.3"
-      env: TARGET=Lint3.5
-      script:
-        - script/ci-custom.py
-        - flake8 esphome
-        - pylint esphome
-    - python: "2.7"
-      env: TARGET=Test2.7
-      script:
-        - esphome tests/test1.yaml compile
-        - esphome tests/test2.yaml compile
-        - esphome tests/test3.yaml compile
-    - env: TARGET=Cpp-Lint
-      dist: trusty
-      sudo: required
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-7
-          packages:
-            - clang-tidy-7
-            - clang-format-7
-      before_script:
-        - pio init --ide atom
-        - |
-          if ! patch -R -p0 -s -f --dry-run <script/.neopixelbus.patch; then
-            patch -p0 < script/.neopixelbus.patch
-          fi
-        - clang-tidy-7 -version
-        - clang-format-7 -version
-        - clang-apply-replacements-7 -version
-      script:
-        - script/clang-tidy --all-headers -j 2 --fix
-        - script/clang-format -i -j 2
-        - script/ci-suggest-changes

.vscode/tasks.json

@@ -0,0 +1,11 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "run",
+            "type": "shell",
+            "command": "python3 -m esphome dashboard config",
+            "problemMatcher": []
+        }
+    ]
+}

CODEOWNERS

@@ -0,0 +1,132 @@
+# This file is generated by script/build_codeowners.py
+# People marked here will be automatically requested for a review
+# when the code that they own is touched.
+#
+# Every time an issue is created with a label corresponding to an integration,
+# the integration's code owner is automatically notified.
+
+# Core Code
+setup.py @esphome/core
+esphome/*.py @esphome/core
+esphome/core/* @esphome/core
+
+# Integrations
+esphome/components/ac_dimmer/* @glmnet
+esphome/components/adc/* @esphome/core
+esphome/components/addressable_light/* @justfalter
+esphome/components/animation/* @syndlex
+esphome/components/api/* @OttoWinter
+esphome/components/async_tcp/* @OttoWinter
+esphome/components/atc_mithermometer/* @ahpohl
+esphome/components/b_parasite/* @rbaron
+esphome/components/bang_bang/* @OttoWinter
+esphome/components/binary_sensor/* @esphome/core
+esphome/components/ble_client/* @buxtronix
+esphome/components/bme680_bsec/* @trvrnrth
+esphome/components/canbus/* @danielschramm @mvturnho
+esphome/components/captive_portal/* @OttoWinter
+esphome/components/climate/* @esphome/core
+esphome/components/climate_ir/* @glmnet
+esphome/components/coolix/* @glmnet
+esphome/components/cover/* @esphome/core
+esphome/components/cs5460a/* @balrog-kun
+esphome/components/ct_clamp/* @jesserockz
+esphome/components/debug/* @OttoWinter
+esphome/components/dfplayer/* @glmnet
+esphome/components/dht/* @OttoWinter
+esphome/components/ds1307/* @badbadc0ffee
+esphome/components/esp32_ble/* @jesserockz
+esphome/components/esp32_ble_server/* @jesserockz
+esphome/components/esp32_improv/* @jesserockz
+esphome/components/exposure_notifications/* @OttoWinter
+esphome/components/ezo/* @ssieb
+esphome/components/fastled_base/* @OttoWinter
+esphome/components/fingerprint_grow/* @OnFreund @loongyh
+esphome/components/globals/* @esphome/core
+esphome/components/gpio/* @esphome/core
+esphome/components/gps/* @coogle
+esphome/components/homeassistant/* @OttoWinter
+esphome/components/i2c/* @esphome/core
+esphome/components/improv/* @jesserockz
+esphome/components/inkbird_ibsth1_mini/* @fkirill
+esphome/components/inkplate6/* @jesserockz
+esphome/components/integration/* @OttoWinter
+esphome/components/interval/* @esphome/core
+esphome/components/json/* @OttoWinter
+esphome/components/ledc/* @OttoWinter
+esphome/components/light/* @esphome/core
+esphome/components/logger/* @esphome/core
+esphome/components/max7219digit/* @rspaargaren
+esphome/components/mcp23008/* @jesserockz
+esphome/components/mcp23017/* @jesserockz
+esphome/components/mcp23s08/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23s17/* @SenexCrenshaw @jesserockz
+esphome/components/mcp23x08_base/* @jesserockz
+esphome/components/mcp23x17_base/* @jesserockz
+esphome/components/mcp23xxx_base/* @jesserockz
+esphome/components/mcp2515/* @danielschramm @mvturnho
+esphome/components/mcp9808/* @k7hpn
+esphome/components/midea_ac/* @dudanov
+esphome/components/midea_dongle/* @dudanov
+esphome/components/mitsubishi/* @RubyBailey
+esphome/components/network/* @esphome/core
+esphome/components/nfc/* @jesserockz
+esphome/components/ota/* @esphome/core
+esphome/components/output/* @esphome/core
+esphome/components/pid/* @OttoWinter
+esphome/components/pn532/* @OttoWinter @jesserockz
+esphome/components/pn532_i2c/* @OttoWinter @jesserockz
+esphome/components/pn532_spi/* @OttoWinter @jesserockz
+esphome/components/power_supply/* @esphome/core
+esphome/components/pulse_meter/* @stevebaxter
+esphome/components/rc522/* @glmnet
+esphome/components/rc522_i2c/* @glmnet
+esphome/components/rc522_spi/* @glmnet
+esphome/components/restart/* @esphome/core
+esphome/components/rf_bridge/* @jesserockz
+esphome/components/rtttl/* @glmnet
+esphome/components/script/* @esphome/core
+esphome/components/sdm_meter/* @jesserockz @polyfaces
+esphome/components/sensor/* @esphome/core
+esphome/components/sgp40/* @SenexCrenshaw
+esphome/components/sht4x/* @sjtrny
+esphome/components/shutdown/* @esphome/core
+esphome/components/sim800l/* @glmnet
+esphome/components/sm2135/* @BoukeHaarsma23
+esphome/components/spi/* @esphome/core
+esphome/components/ssd1322_base/* @kbx81
+esphome/components/ssd1322_spi/* @kbx81
+esphome/components/ssd1325_base/* @kbx81
+esphome/components/ssd1325_spi/* @kbx81
+esphome/components/ssd1327_base/* @kbx81
+esphome/components/ssd1327_i2c/* @kbx81
+esphome/components/ssd1327_spi/* @kbx81
+esphome/components/ssd1331_base/* @kbx81
+esphome/components/ssd1331_spi/* @kbx81
+esphome/components/ssd1351_base/* @kbx81
+esphome/components/ssd1351_spi/* @kbx81
+esphome/components/st7735/* @SenexCrenshaw
+esphome/components/st7789v/* @kbx81
+esphome/components/substitutions/* @esphome/core
+esphome/components/sun/* @OttoWinter
+esphome/components/switch/* @esphome/core
+esphome/components/tca9548a/* @andreashergert1984
+esphome/components/tcl112/* @glmnet
+esphome/components/teleinfo/* @0hax
+esphome/components/thermostat/* @kbx81
+esphome/components/time/* @OttoWinter
+esphome/components/tm1637/* @glmnet
+esphome/components/tmp102/* @timsavage
+esphome/components/tof10120/* @wstrzalka
+esphome/components/tuya/binary_sensor/* @jesserockz
+esphome/components/tuya/climate/* @jesserockz
+esphome/components/tuya/sensor/* @jesserockz
+esphome/components/tuya/switch/* @jesserockz
+esphome/components/uart/* @esphome/core
+esphome/components/ultrasonic/* @OttoWinter
+esphome/components/version/* @esphome/core
+esphome/components/web_server_base/* @OttoWinter
+esphome/components/whirlpool/* @glmnet
+esphome/components/xiaomi_lywsd03mmc/* @ahpohl
+esphome/components/xiaomi_mhoc401/* @vevsvevs
+esphome/components/xpt2046/* @numo68

CODE_OF_CONDUCT.md

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

MANIFEST.in

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

docker/Dockerfile

@@ -1,9 +1,30 @@
-ARG BUILD_FROM=esphome/esphome-base-amd64:1.5.1
+ARG BUILD_FROM=esphome/esphome-base-amd64:3.4.0
 FROM ${BUILD_FROM}
 
-COPY . .
-RUN pip2 install --no-cache-dir -e .
+# First install requirements to leverage caching when requirements don't change
+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 .
+
+# Settings for dashboard
+ENV USERNAME="" PASSWORD=""
+
+# Expose the dashboard to Docker
+EXPOSE 6052
+
+# Run healthcheck (heartbeat)
+HEALTHCHECK --interval=30s --timeout=30s \
+  CMD curl --fail http://localhost:6052 || exit 1
+
+# The directory the user should mount their configuration files to
 WORKDIR /config
+# Set entrypoint to esphome so that the user doesn't have to type 'esphome'
+# in every docker command twice
 ENTRYPOINT ["esphome"]
-CMD ["/config", "dashboard"]
+# When no arguments given, start the dashboard in the workdir
+CMD ["dashboard", "/config"]

docker/Dockerfile.dev

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

docker/Dockerfile.hassio

@@ -1,12 +1,18 @@
 ARG BUILD_FROM
 FROM ${BUILD_FROM}
 
+# First install requirements to leverage caching when requirements don't change
+COPY requirements.txt requirements_optional.txt docker/platformio_install_deps.py platformio.ini /
+RUN \
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_optional.txt \
+    && /platformio_install_deps.py /platformio.ini
+
 # Copy root filesystem
 COPY docker/rootfs/ /
-COPY setup.py setup.cfg MANIFEST.in /opt/esphome/
-COPY esphome /opt/esphome/esphome
 
-RUN pip2 install --no-cache-dir -e /opt/esphome
+# Then copy esphome and install
+COPY . /opt/esphome/
+RUN pip3 install --no-cache-dir -e /opt/esphome
 
 # Build arguments
 ARG BUILD_VERSION=dev

docker/Dockerfile.lint

@@ -1,18 +1,9 @@
-FROM esphome/esphome-base-amd64:1.5.1
+FROM esphome/esphome-lint-base:3.4.0
 
+COPY requirements.txt requirements_optional.txt requirements_test.txt docker/platformio_install_deps.py  platformio.ini /
 RUN \
-    apt-get update \
-    && apt-get install -y --no-install-recommends \
-        clang-format-7 \
-        clang-tidy-7 \
-        patch \
-    && rm -rf \
-        /tmp/* \
-        /var/{cache,log}/* \
-        /var/lib/apt/lists/*
-
-COPY requirements_test.txt /requirements_test.txt
-RUN pip2 install -r /requirements_test.txt
+    pip3 install --no-cache-dir -r /requirements.txt -r /requirements_optional.txt -r /requirements_test.txt \
+    && /platformio_install_deps.py /platformio.ini
 
 VOLUME ["/esphome"]
 WORKDIR /esphome

docker/Dockerfile.test

@@ -1,21 +0,0 @@
-FROM ubuntu:bionic
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-        python \
-        python-pip \
-        python-setuptools \
-        python-pil \
-        git \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/*rm -rf /var/lib/apt/lists/* /tmp/* && \
-    pip install --no-cache-dir platformio && \
-    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
-
-COPY docker/platformio.ini /pio/platformio.ini
-RUN platformio run -d /pio; rm -rf /pio
-
-COPY requirements.txt /requirements.txt
-
-RUN pip install --no-cache-dir -r /requirements.txt

docker/platformio.ini

@@ -1,12 +0,0 @@
-; This file allows the docker build file to install the required platformio
-; platforms
-
-[env:espressif8266]
-platform = espressif8266@1.8.0
-board = nodemcuv2
-framework = arduino
-
-[env:espressif32]
-platform = espressif32@1.5.0
-board = nodemcu-32s
-framework = arduino

docker/platformio_install_deps.py

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

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

@@ -8,8 +8,16 @@ declare esphome_version
 
 if bashio::config.has_value 'esphome_version'; then
     esphome_version=$(bashio::config 'esphome_version')
-    full_url="https://github.com/esphome/esphome/archive/${esphome_version}.zip"
+    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})..."
-    pip2 install -U --no-cache-dir "${full_url}" \
+    pip3 install -U --no-cache-dir "${full_url}" \
       || bashio::exit.nok "Failed installing esphome pinned version."
 fi

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

@@ -4,6 +4,11 @@ server {
     include /etc/nginx/includes/server_params.conf;
     include /etc/nginx/includes/proxy_params.conf;
     include /etc/nginx/includes/ssl_params.conf;
+
+    ssl on;
+    ssl_certificate /ssl/%%certfile%%;
+    ssl_certificate_key /ssl/%%keyfile%%;
+
     # Clear Hass.io Ingress header
     proxy_set_header X-Hassio-Ingress "";
 

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

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

esphome/__main__.py

@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import argparse
 import functools
 import logging
@@ -10,42 +8,47 @@ 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
-from esphome.core import CORE, EsphomeError, coroutine, coroutine_with_priority
-from esphome.helpers import color, indent
-from esphome.py_compat import IS_PY2, safe_input
-from esphome.util import run_external_command, run_external_process, safe_print
+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
+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 get_serial_ports():
-    # from https://github.com/pyserial/pyserial/blob/master/serial/tools/list_ports.py
-    from serial.tools.list_ports import comports
-    result = []
-    for port, desc, info in comports():
-        if not port:
-            continue
-        if "VID:PID" in info:
-            result.append((port, desc))
-    result.sort(key=lambda x: x[0])
-    return result
-
-
 def choose_prompt(options):
     if not options:
-        raise ValueError
+        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]
 
-    safe_print(u"Found multiple options, please choose one:")
+    safe_print("Found multiple options, please choose one:")
     for i, (desc, _) in enumerate(options):
-        safe_print(u"  [{}] {}".format(i + 1, desc))
+        safe_print(f"  [{i+1}] {desc}")
 
     while True:
-        opt = safe_input('(number): ')
+        opt = input("(number): ")
         if opt in options:
             opt = options.index(opt)
             break
@@ -55,22 +58,22 @@ def choose_prompt(options):
                 raise ValueError
             break
         except ValueError:
-            safe_print(color('red', u"Invalid option: '{}'".format(opt)))
+            safe_print(color(Fore.RED, f"Invalid option: '{opt}'"))
     return options[opt - 1][1]
 
 
 def choose_upload_log_host(default, check_default, show_ota, show_mqtt, show_api):
     options = []
-    for res, desc in get_serial_ports():
-        options.append((u"{} ({})".format(res, desc), res))
-    if (show_ota and 'ota' in CORE.config) or (show_api and 'api' in CORE.config):
-        options.append((u"Over The Air ({})".format(CORE.address), CORE.address))
-        if default == 'OTA':
+    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):
+        options.append((f"Over The Air ({CORE.address})", CORE.address))
+        if default == "OTA":
             return CORE.address
-    if show_mqtt and 'mqtt' in CORE.config:
-        options.append((u"MQTT ({})".format(CORE.config['mqtt'][CONF_BROKER]), 'MQTT'))
-        if default == 'OTA':
-            return 'MQTT'
+    if show_mqtt and "mqtt" in CORE.config:
+        options.append(("MQTT ({})".format(CORE.config["mqtt"][CONF_BROKER]), "MQTT"))
+        if default == "OTA":
+            return "MQTT"
     if default is not None:
         return default
     if check_default is not None and check_default in [opt[1] for opt in options]:
@@ -79,11 +82,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):
@@ -93,7 +96,7 @@ 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.")
     _LOGGER.info("Starting log output from %s with baud rate %s", port, baud_rate)
@@ -106,37 +109,43 @@ def run_miniterm(config, port):
             except serial.SerialException:
                 _LOGGER.error("Serial port closed!")
                 return
-            if IS_PY2:
-                line = raw.replace('\r', '').replace('\n', '')
-            else:
-                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):
-        cg.add(cg.LineComment(u"{}:".format(name)))
+    async def wrapped(conf):
+        cg.add(cg.LineComment(f"{name}:"))
         if comp.config_schema is not None:
             conf_str = yaml_util.dump(conf)
-            if IS_PY2:
-                conf_str = conf_str.decode('utf-8')
+            conf_str = conf_str.replace("//", "")
             cg.add(cg.LineComment(indent(conf_str)))
-        yield coro(conf)
+        await coro(conf)
 
+    if hasattr(coro, "priority"):
+        wrapped.priority = coro.priority
     return wrapped
 
 
 def write_cpp(config):
+    generate_cpp_contents(config)
+    return write_cpp_file()
+
+
+def generate_cpp_contents(config):
     _LOGGER.info("Generating C++ source...")
 
     for name, component, conf in iter_components(CORE.config):
@@ -146,6 +155,8 @@ def write_cpp(config):
 
     CORE.flush_tasks()
 
+
+def write_cpp_file():
     writer.write_platformio_project()
 
     code_s = indent(CORE.cpp_main_section)
@@ -157,54 +168,91 @@ def compile_program(args, config):
     from esphome import platformio_api
 
     _LOGGER.info("Compiling app...")
-    return platformio_api.run_compile(config, args.verbose)
+    return platformio_api.run_compile(config, CORE.verbose)
 
 
 def upload_using_esptool(config, port):
     path = CORE.firmware_bin
-    cmd = ['esptool.py', '--before', 'default_reset', '--after', 'hard_reset',
-           '--chip', 'esp8266', '--port', port, 'write_flash', '0x0', path]
+    first_baudrate = config[CONF_ESPHOME][CONF_PLATFORMIO_OPTIONS].get(
+        "upload_speed", 460800
+    )
 
-    if os.environ.get('ESPHOME_USE_SUBPROCESS') is None:
-        import esptool
-        # pylint: disable=protected-access
-        return run_external_command(esptool._main, *cmd)
+    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,
+        ]
 
-    return run_external_process(*cmd)
+        if os.environ.get("ESPHOME_USE_SUBPROCESS") is None:
+            import esptool
+
+            # pylint: disable=protected-access
+            return run_external_command(esptool._main, *cmd)
+
+        return run_external_process(*cmd)
+
+    rc = run_esptool(first_baudrate)
+    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,
+    )
+    return run_esptool(115200)
 
 
 def upload_program(config, args, host):
     # if upload is to a serial port use platformio, otherwise assume ota
-    if get_port_type(host) == 'SERIAL':
+    if get_port_type(host) == "SERIAL":
         from esphome import platformio_api
 
         if CORE.is_esp8266:
             return upload_using_esptool(config, host)
-        return platformio_api.run_upload(config, args.verbose, host)
+        return platformio_api.run_upload(config, CORE.verbose, 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"
+        )
+
     ota_conf = config[CONF_OTA]
     remote_port = ota_conf[CONF_PORT]
     password = ota_conf[CONF_PASSWORD]
-    res = espota2.run_ota(host, remote_port, password, CORE.firmware_bin)
-    return res
+    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:
+    if get_port_type(port) == "NETWORK" and "api" in config:
         from esphome.api.client import run_logs
 
         return run_logs(config, port)
-    if get_port_type(port) == 'MQTT' and 'mqtt' in config:
+    if get_port_type(port) == "MQTT" and "mqtt" in config:
         from esphome import mqtt
 
-        return mqtt.show_logs(config, args.topic, args.username, args.password, args.client_id)
+        return mqtt.show_logs(
+            config, args.topic, args.username, args.password, args.client_id
+        )
 
     raise EsphomeError("No remote or local logging method configured (api/mqtt/logger)")
 
@@ -212,39 +260,9 @@ 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
-    elif quiet:
-        log_level = logging.CRITICAL
-    else:
-        log_level = logging.INFO
-    logging.basicConfig(level=log_level)
-    fmt = "%(levelname)s %(message)s"
-    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
-    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):
@@ -255,7 +273,7 @@ def command_wizard(args):
 
 def command_config(args, config):
     _LOGGER.info("Configuration is valid!")
-    if not args.verbose:
+    if not CORE.verbose:
         config = strip_default_ids(config)
     safe_print(yaml_util.dump(config))
     return 0
@@ -264,6 +282,8 @@ def command_config(args, config):
 def command_vscode(args):
     from esphome import vscode
 
+    logging.disable(logging.INFO)
+    logging.disable(logging.WARNING)
     CORE.config_path = args.configuration
     vscode.read_config(args)
 
@@ -273,28 +293,38 @@ def command_compile(args, config):
     if exit_code != 0:
         return exit_code
     if args.only_generate:
-        _LOGGER.info(u"Successfully generated source code.")
+        _LOGGER.info("Successfully generated source code.")
         return 0
     exit_code = compile_program(args, config)
     if exit_code != 0:
         return exit_code
-    _LOGGER.info(u"Successfully compiled program.")
+    _LOGGER.info("Successfully compiled program.")
     return 0
 
 
 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
-    _LOGGER.info(u"Successfully uploaded program.")
+    _LOGGER.info("Successfully uploaded program.")
     return 0
 
 
 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)
 
 
@@ -305,17 +335,27 @@ def command_run(args, config):
     exit_code = compile_program(args, config)
     if exit_code != 0:
         return exit_code
-    _LOGGER.info(u"Successfully compiled program.")
-    port = choose_upload_log_host(default=args.upload_port, check_default=None,
-                                  show_ota=True, show_mqtt=False, show_api=True)
+    _LOGGER.info("Successfully compiled program.")
+    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(u"Successfully uploaded program.")
+    _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)
 
 
@@ -330,7 +370,7 @@ def command_mqtt_fingerprint(args, config):
 
 
 def command_version(args):
-    safe_print(u"Version: {}".format(const.__version__))
+    safe_print(f"Version: {const.__version__}")
     return 0
 
 
@@ -350,101 +390,294 @@ def command_dashboard(args):
     return dashboard.start_web_server(args)
 
 
+def command_update_all(args):
+    import click
+
+    success = {}
+    files = list_yaml_files(args.configuration[0])
+    twidth = 60
+
+    def print_bar(middle_text):
+        middle_text = f" {middle_text} "
+        width = len(click.unstyle(middle_text))
+        half_line = "=" * ((twidth - width) // 2)
+        click.echo(f"{half_line}{middle_text}{half_line}")
+
+    for f in files:
+        print("Updating {}".format(color(Fore.CYAN, f)))
+        print("-" * twidth)
+        print()
+        rc = run_external_process(
+            "esphome", "--dashboard", "run", "--no-logs", "--device", "OTA", f
+        )
+        if rc == 0:
+            print_bar("[{}] {}".format(color(Fore.BOLD_GREEN, "SUCCESS"), f))
+            success[f] = True
+        else:
+            print_bar("[{}] {}".format(color(Fore.BOLD_RED, "ERROR"), f))
+            success[f] = False
+
+        print()
+        print()
+        print()
+
+    print_bar("[{}]".format(color(Fore.BOLD_WHITE, "SUMMARY")))
+    failed = 0
+    for f in files:
+        if success[f]:
+            print("  - {}: {}".format(f, color(Fore.GREEN, "SUCCESS")))
+        else:
+            print("  - {}: {}".format(f, color(Fore.BOLD_RED, "FAILED")))
+            failed += 1
+    return failed
+
+
 PRE_CONFIG_ACTIONS = {
-    'wizard': command_wizard,
-    'version': command_version,
-    'dashboard': command_dashboard,
-    'vscode': command_vscode,
+    "wizard": command_wizard,
+    "version": command_version,
+    "dashboard": command_dashboard,
+    "vscode": command_vscode,
+    "update-all": command_update_all,
 }
 
 POST_CONFIG_ACTIONS = {
-    'config': command_config,
-    'compile': command_compile,
-    'upload': command_upload,
-    'logs': command_logs,
-    'run': command_run,
-    'clean-mqtt': command_clean_mqtt,
-    'mqtt-fingerprint': command_mqtt_fingerprint,
-    'clean': command_clean,
+    "config": command_config,
+    "compile": command_compile,
+    "upload": command_upload,
+    "logs": command_logs,
+    "run": command_run,
+    "clean-mqtt": command_clean_mqtt,
+    "mqtt-fingerprint": command_mqtt_fingerprint,
+    "clean": command_clean,
 }
 
 
 def parse_args(argv):
-    parser = argparse.ArgumentParser(prog='esphome')
-    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('configuration', help='Your YAML configuration file.')
+    options_parser = argparse.ArgumentParser(add_help=False)
+    options_parser.add_argument(
+        "-v", "--verbose", help="Enable verbose ESPHome logs.", action="store_true"
+    )
+    options_parser.add_argument(
+        "-q", "--quiet", help="Disable all ESPHome logs.", action="store_true"
+    )
+    options_parser.add_argument(
+        "--dashboard", help=argparse.SUPPRESS, action="store_true"
+    )
+    options_parser.add_argument(
+        "-s",
+        "--substitution",
+        nargs=2,
+        action="append",
+        help="Add a substitution",
+        metavar=("key", "value"),
+    )
 
-    subparsers = parser.add_subparsers(help='Commands', dest='command')
+    # Keep backward compatibility with the old command line format of
+    # esphome <config> <command>.
+    #
+    # Unfortunately this can't be done by adding another configuration argument to the
+    # main config parser, as argparse is greedy when parsing arguments, so in regular
+    # usage it'll eat the command as the configuration argument and error out out
+    # because it can't parse the configuration as a command.
+    #
+    # Instead, construct an ad-hoc parser for the old format that doesn't actually
+    # process the arguments, but parses them enough to let us figure out if the old
+    # format is used. In that case, swap the command and configuration in the arguments
+    # and continue on with the normal parser (after raising a deprecation warning).
+    #
+    # Disable argparse's built-in help option and add it manually to prevent this
+    # parser from printing the help messagefor the old format when invoked with -h.
+    compat_parser = argparse.ArgumentParser(parents=[options_parser], add_help=False)
+    compat_parser.add_argument("-h", "--help")
+    compat_parser.add_argument("configuration", nargs="*")
+    compat_parser.add_argument(
+        "command",
+        choices=[
+            "config",
+            "compile",
+            "upload",
+            "logs",
+            "run",
+            "clean-mqtt",
+            "wizard",
+            "mqtt-fingerprint",
+            "version",
+            "clean",
+            "dashboard",
+            "vscode",
+        ],
+    )
+
+    # on Python 3.9+ we can simply set exit_on_error=False in the constructor
+    def _raise(x):
+        raise argparse.ArgumentError(None, x)
+
+    compat_parser.error = _raise
+
+    try:
+        result, unparsed = compat_parser.parse_known_args(argv[1:])
+        last_option = len(argv) - len(unparsed) - 1 - len(result.configuration)
+        argv = argv[0:last_option] + [result.command] + result.configuration + unparsed
+        deprecated_argv_suggestion = argv
+    except argparse.ArgumentError:
+        # This is not an old-style command line, so we don't have to do anything.
+        deprecated_argv_suggestion = None
+
+    # And continue on with regular parsing
+    parser = argparse.ArgumentParser(
+        description=f"ESPHome v{const.__version__}", parents=[options_parser]
+    )
+    parser.set_defaults(deprecated_argv_suggestion=deprecated_argv_suggestion)
+
+    mqtt_options = argparse.ArgumentParser(add_help=False)
+    mqtt_options.add_argument("--topic", help="Manually set the MQTT topic.")
+    mqtt_options.add_argument("--username", help="Manually set the MQTT username.")
+    mqtt_options.add_argument("--password", help="Manually set the MQTT password.")
+    mqtt_options.add_argument("--client-id", help="Manually set the MQTT client id.")
+
+    subparsers = parser.add_subparsers(
+        help="Command to run:", dest="command", metavar="command"
+    )
     subparsers.required = True
-    subparsers.add_parser('config', help='Validate the configuration and spit it out.')
 
-    parser_compile = subparsers.add_parser('compile',
-                                           help='Read the configuration and compile a program.')
-    parser_compile.add_argument('--only-generate',
-                                help="Only generate source code, do not compile.",
-                                action='store_true')
+    parser_config = subparsers.add_parser(
+        "config", help="Validate the configuration and spit it out."
+    )
+    parser_config.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    parser_upload = subparsers.add_parser('upload', help='Validate the configuration '
-                                                         'and upload the latest binary.')
-    parser_upload.add_argument('--upload-port', help="Manually specify the upload port to use. "
-                                                     "For example /dev/cu.SLAB_USBtoUART.")
+    parser_compile = subparsers.add_parser(
+        "compile", help="Read the configuration and compile a program."
+    )
+    parser_compile.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_compile.add_argument(
+        "--only-generate",
+        help="Only generate source code, do not compile.",
+        action="store_true",
+    )
 
-    parser_logs = subparsers.add_parser('logs', help='Validate the configuration '
-                                                     'and show all MQTT logs.')
-    parser_logs.add_argument('--topic', help='Manually set the topic to subscribe to.')
-    parser_logs.add_argument('--username', help='Manually set the username.')
-    parser_logs.add_argument('--password', help='Manually set the password.')
-    parser_logs.add_argument('--client-id', help='Manually set the client id.')
-    parser_logs.add_argument('--serial-port', help="Manually specify a serial port to use"
-                                                   "For example /dev/cu.SLAB_USBtoUART.")
+    parser_upload = subparsers.add_parser(
+        "upload", help="Validate the configuration and upload the latest binary."
+    )
+    parser_upload.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_upload.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
 
-    parser_run = subparsers.add_parser('run', help='Validate the configuration, create a binary, '
-                                                   'upload it, and start MQTT logs.')
-    parser_run.add_argument('--upload-port', help="Manually specify the upload port/ip to use. "
-                                                  "For example /dev/cu.SLAB_USBtoUART.")
-    parser_run.add_argument('--no-logs', help='Disable starting MQTT logs.',
-                            action='store_true')
-    parser_run.add_argument('--topic', help='Manually set the topic to subscribe to for logs.')
-    parser_run.add_argument('--username', help='Manually set the MQTT username for logs.')
-    parser_run.add_argument('--password', help='Manually set the MQTT password for logs.')
-    parser_run.add_argument('--client-id', help='Manually set the client id for logs.')
+    parser_logs = subparsers.add_parser(
+        "logs",
+        help="Validate the configuration and show all logs.",
+        parents=[mqtt_options],
+    )
+    parser_logs.add_argument(
+        "configuration", help="Your YAML configuration file.", nargs=1
+    )
+    parser_logs.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
 
-    parser_clean = subparsers.add_parser('clean-mqtt', help="Helper to clear an MQTT topic from "
-                                                            "retain messages.")
-    parser_clean.add_argument('--topic', help='Manually set the topic to subscribe to.')
-    parser_clean.add_argument('--username', help='Manually set the username.')
-    parser_clean.add_argument('--password', help='Manually set the password.')
-    parser_clean.add_argument('--client-id', help='Manually set the client id.')
+    parser_run = subparsers.add_parser(
+        "run",
+        help="Validate the configuration, create a binary, upload it, and start logs.",
+        parents=[mqtt_options],
+    )
+    parser_run.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
+    parser_run.add_argument(
+        "--device",
+        help="Manually specify the serial port/address to use, for example /dev/ttyUSB0.",
+    )
+    parser_run.add_argument(
+        "--no-logs", help="Disable starting logs.", action="store_true"
+    )
 
-    subparsers.add_parser('wizard', help="A helpful setup wizard that will guide "
-                                         "you through setting up esphome.")
+    parser_clean = subparsers.add_parser(
+        "clean-mqtt",
+        help="Helper to clear retained messages from an MQTT topic.",
+        parents=[mqtt_options],
+    )
+    parser_clean.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    subparsers.add_parser('mqtt-fingerprint', help="Get the SSL fingerprint from a MQTT broker.")
+    parser_wizard = subparsers.add_parser(
+        "wizard",
+        help="A helpful setup wizard that will guide you through setting up ESPHome.",
+    )
+    parser_wizard.add_argument(
+        "configuration",
+        help="Your YAML configuration file.",
+    )
 
-    subparsers.add_parser('version', help="Print the esphome version and exit.")
+    parser_fingerprint = subparsers.add_parser(
+        "mqtt-fingerprint", help="Get the SSL fingerprint from a MQTT broker."
+    )
+    parser_fingerprint.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    subparsers.add_parser('clean', help="Delete all temporary build files.")
+    subparsers.add_parser("version", help="Print the ESPHome version and exit.")
 
-    dashboard = subparsers.add_parser('dashboard',
-                                      help="Create a simple web server for a dashboard.")
-    dashboard.add_argument("--port", help="The HTTP port to open connections on. Defaults to 6052.",
-                           type=int, default=6052)
-    dashboard.add_argument("--password", help="The optional password to require for all requests.",
-                           type=str, default='')
-    dashboard.add_argument("--open-ui", help="Open the dashboard UI in a browser.",
-                           action='store_true')
-    dashboard.add_argument("--hassio",
-                           help=argparse.SUPPRESS,
-                           action="store_true")
-    dashboard.add_argument("--socket",
-                           help="Make the dashboard serve under a unix socket", type=str)
+    parser_clean = subparsers.add_parser(
+        "clean", help="Delete all temporary build files."
+    )
+    parser_clean.add_argument(
+        "configuration", help="Your YAML configuration file(s).", nargs="+"
+    )
 
-    vscode = subparsers.add_parser('vscode', help=argparse.SUPPRESS)
-    vscode.add_argument('--ace', action='store_true')
+    parser_dashboard = subparsers.add_parser(
+        "dashboard", help="Create a simple web server for a dashboard."
+    )
+    parser_dashboard.add_argument(
+        "configuration",
+        help="Your YAML configuration file directory.",
+    )
+    parser_dashboard.add_argument(
+        "--port",
+        help="The HTTP port to open connections on. Defaults to 6052.",
+        type=int,
+        default=6052,
+    )
+    parser_dashboard.add_argument(
+        "--username",
+        help="The optional username to require for authentication.",
+        type=str,
+        default="",
+    )
+    parser_dashboard.add_argument(
+        "--password",
+        help="The optional password to require for authentication.",
+        type=str,
+        default="",
+    )
+    parser_dashboard.add_argument(
+        "--open-ui", help="Open the dashboard UI in a browser.", action="store_true"
+    )
+    parser_dashboard.add_argument(
+        "--hassio", help=argparse.SUPPRESS, action="store_true"
+    )
+    parser_dashboard.add_argument(
+        "--socket", help="Make the dashboard serve under a unix socket", type=str
+    )
+
+    parser_vscode = subparsers.add_parser("vscode")
+    parser_vscode.add_argument(
+        "configuration", help="Your YAML configuration file.", nargs=1
+    )
+    parser_vscode.add_argument("--ace", action="store_true")
+
+    parser_update = subparsers.add_parser("update-all")
+    parser_update.add_argument(
+        "configuration", help="Your YAML configuration file directory.", nargs=1
+    )
 
     return parser.parse_args(argv[1:])
 
@@ -454,28 +687,50 @@ def run_esphome(argv):
     CORE.dashboard = args.dashboard
 
     setup_log(args.verbose, args.quiet)
+    if args.deprecated_argv_suggestion is not None and args.command != "vscode":
+        _LOGGER.warning(
+            "Calling ESPHome with the configuration before the command is deprecated "
+            "and will be removed in the future. "
+        )
+        _LOGGER.warning("Please instead use:")
+        _LOGGER.warning("   esphome %s", " ".join(args.deprecated_argv_suggestion[1:]))
+
+    if sys.version_info < (3, 7, 0):
+        _LOGGER.error(
+            "You're running ESPHome with Python <3.7. ESPHome is no longer compatible "
+            "with this Python version. Please reinstall ESPHome with Python 3.7+"
+        )
+        return 1
+
     if args.command in PRE_CONFIG_ACTIONS:
         try:
             return PRE_CONFIG_ACTIONS[args.command](args)
         except EsphomeError as e:
-            _LOGGER.error(e)
+            _LOGGER.error(e, exc_info=args.verbose)
             return 1
 
-    CORE.config_path = args.configuration
+    for conf_path in args.configuration:
+        CORE.config_path = conf_path
+        CORE.dashboard = args.dashboard
 
-    config = read_config(args.verbose)
-    if config is None:
-        return 1
-    CORE.config = config
+        config = read_config(dict(args.substitution) if args.substitution else {})
+        if config is None:
+            return 1
+        CORE.config = config
+
+        if args.command not in POST_CONFIG_ACTIONS:
+            safe_print(f"Unknown command {args.command}")
 
-    if args.command in POST_CONFIG_ACTIONS:
         try:
-            return POST_CONFIG_ACTIONS[args.command](args, config)
+            rc = POST_CONFIG_ACTIONS[args.command](args, config)
         except EsphomeError as e:
-            _LOGGER.error(e)
+            _LOGGER.error(e, exc_info=args.verbose)
             return 1
-    safe_print(u"Unknown command {}".format(args.command))
-    return 1
+        if rc != 0:
+            return rc
+
+        CORE.reset()
+    return 0
 
 
 def main():

esphome/api/api.proto

@@ -1,330 +0,0 @@
-syntax = "proto3";
-
-// 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:
-//  * 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
-
-// The connection is established in 4 steps:
-//  * First, the client connects to the server and sends a "Hello Request" identifying itself
-//  * The server responds with a "Hello Response" and selects the protocol version
-//  * After receiving this message, the client attempts to authenticate itself using
-//    the password and a "Connect Request"
-//  * The server responds with a "Connect Response" and notifies of invalid password.
-// If anything in this initial process fails, the connection must immediately closed
-// by both sides and _no_ disconnection message is to be sent.
-
-// Message sent at the beginning of each connection
-// Can only be sent by the client and only at the beginning of the connection
-message HelloRequest {
-  // Description of client (like User Agent)
-  // For example "Home Assistant"
-  // Not strictly necessary to send but nice for debugging
-  // purposes.
-  string client_info = 1;
-}
-
-// Confirmation of successful connection request.
-// Can only be sent by the server and only at the beginning of the connection
-message HelloResponse {
-  // The version of the API to use. The _client_ (for example Home Assistant) needs to check
-  // for compatibility and if necessary adopt to an older API.
-  // Major is for breaking changes in the base protocol - a mismatch will lead to immediate disconnect_client_
-  // Minor is for breaking changes in individual messages - a mismatch will lead to a warning message
-  uint32 api_version_major = 1;
-  uint32 api_version_minor = 2;
-
-  // A string identifying the server (ESP); like client info this may be empty
-  // and only exists for debugging/logging purposes.
-  // For example "ESPHome v1.10.0 on ESP8266"
-  string server_info = 3;
-}
-
-// Message sent at the beginning of each connection to authenticate the client
-// Can only be sent by the client and only at the beginning of the connection
-message ConnectRequest {
-  // The password to log in with
-  string password = 1;
-}
-
-// Confirmation of successful connection. After this the connection is available for all traffic.
-// Can only be sent by the server and only at the beginning of the connection
-message ConnectResponse {
-  bool invalid_password = 1;
-}
-
-// Request to close the connection.
-// Can be sent by both the client and server
-message DisconnectRequest {
-  // Do not close the connection before the acknowledgement arrives
-}
-
-message DisconnectResponse {
-  // Empty - Both parties are required to close the connection after this
-  // message has been received.
-}
-
-message PingRequest {
-  // Empty
-}
-
-message PingResponse {
-  // Empty
-}
-
-message DeviceInfoRequest {
-  // Empty
-}
-
-message DeviceInfoResponse {
-  bool uses_password = 1;
-
-  // The name of the node, given by "App.set_name()"
-  string name = 2;
-
-  // The mac address of the device. For example "AC:BC:32:89:0E:A9"
-  string mac_address = 3;
-
-  // A string describing the ESPHome version. For example "1.10.0"
-  string esphome_core_version = 4;
-
-  // A string describing the date of compilation, this is generated by the compiler
-  // and therefore may not be in the same format all the time.
-  // If the user isn't using esphome, this will also not be set.
-  string compilation_time = 5;
-
-  // The model of the board. For example NodeMCU
-  string model = 6;
-
-  bool has_deep_sleep = 7;
-}
-
-message ListEntitiesRequest {
-  // Empty
-}
-
-message ListEntitiesBinarySensorResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  string device_class = 5;
-  bool is_status_binary_sensor = 6;
-}
-message ListEntitiesCoverResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  bool is_optimistic = 5;
-}
-message ListEntitiesFanResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  bool supports_oscillation = 5;
-  bool supports_speed = 6;
-}
-message ListEntitiesLightResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  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;
-  float min_mireds = 9;
-  float max_mireds = 10;
-  repeated string effects = 11;
-}
-message ListEntitiesSensorResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  string icon = 5;
-  string unit_of_measurement = 6;
-  int32 accuracy_decimals = 7;
-}
-message ListEntitiesSwitchResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  string icon = 5;
-  bool optimistic = 6;
-}
-message ListEntitiesTextSensorResponse {
-  string object_id = 1;
-  fixed32 key = 2;
-  string name = 3;
-  string unique_id = 4;
-
-  string icon = 5;
-}
-message ListEntitiesDoneResponse {
-  // Empty
-}
-
-message SubscribeStatesRequest {
-  // Empty
-}
-message BinarySensorStateResponse {
-  fixed32 key = 1;
-  bool state = 2;
-}
-message CoverStateResponse {
-  fixed32 key = 1;
-  enum CoverState {
-    OPEN = 0;
-    CLOSED = 1;
-  }
-  CoverState state = 2;
-}
-enum FanSpeed {
-  LOW = 0;
-  MEDIUM = 1;
-  HIGH = 2;
-}
-message FanStateResponse {
-  fixed32 key = 1;
-  bool state = 2;
-  bool oscillating = 3;
-  FanSpeed speed = 4;
-}
-message LightStateResponse {
-  fixed32 key = 1;
-  bool state = 2;
-  float brightness = 3;
-  float red = 4;
-  float green = 5;
-  float blue = 6;
-  float white = 7;
-  float color_temperature = 8;
-  string effect = 9;
-}
-message SensorStateResponse {
-  fixed32 key = 1;
-  float state = 2;
-}
-message SwitchStateResponse {
-  fixed32 key = 1;
-  bool state = 2;
-}
-message TextSensorStateResponse {
-  fixed32 key = 1;
-  string state = 2;
-}
-
-message CoverCommandRequest {
-  fixed32 key = 1;
-  enum CoverCommand {
-    OPEN = 0;
-    CLOSE = 1;
-    STOP = 2;
-  }
-  bool has_state = 2;
-  CoverCommand command = 3;
-}
-message FanCommandRequest {
-  fixed32 key = 1;
-  bool has_state = 2;
-  bool state = 3;
-  bool has_speed = 4;
-  FanSpeed speed = 5;
-  bool has_oscillating = 6;
-  bool oscillating = 7;
-}
-message LightCommandRequest {
-  fixed32 key = 1;
-  bool has_state = 2;
-  bool state = 3;
-  bool has_brightness = 4;
-  float brightness = 5;
-  bool has_rgb = 6;
-  float red = 7;
-  float green = 8;
-  float blue = 9;
-  bool has_white = 10;
-  float white = 11;
-  bool has_color_temperature = 12;
-  float color_temperature = 13;
-  bool has_transition_length = 14;
-  uint32 transition_length = 15;
-  bool has_flash_length = 16;
-  uint32 flash_length = 17;
-  bool has_effect = 18;
-  string effect = 19;
-}
-message SwitchCommandRequest {
-  fixed32 key = 1;
-  bool state = 2;
-}
-
-enum LogLevel {
-  NONE = 0;
-  ERROR = 1;
-  WARN = 2;
-  INFO = 3;
-  DEBUG = 4;
-  VERBOSE = 5;
-  VERY_VERBOSE = 6;
-}
-
-message SubscribeLogsRequest {
-  LogLevel level = 1;
-  bool dump_config = 2;
-}
-
-message SubscribeLogsResponse {
-  LogLevel level = 1;
-  string tag = 2;
-  string message = 3;
-  bool send_failed = 4;
-}
-
-message SubscribeServiceCallsRequest {
-
-}
-
-message ServiceCallResponse {
-  string service = 1;
-  map<string, string> data = 2;
-  map<string, string> data_template = 3;
-  map<string, string> variables = 4;
-}
-
-// 1. Client sends SubscribeHomeAssistantStatesRequest
-// 2. Server responds with zero or more SubscribeHomeAssistantStateResponse (async)
-// 3. Client sends HomeAssistantStateResponse for state changes.
-message SubscribeHomeAssistantStatesRequest {
-
-}
-
-message SubscribeHomeAssistantStateResponse {
-  string entity_id = 1;
-}
-
-message HomeAssistantStateResponse {
-  string entity_id = 1;
-  string state = 2;
-}
-
-message GetTimeRequest {
-
-}
-
-message GetTimeResponse {
-  fixed32 epoch_seconds = 1;
-}
-

esphome/api/client.py

@@ -13,8 +13,8 @@ from esphome import const
 import esphome.api.api_pb2 as pb
 from esphome.const import CONF_PASSWORD, CONF_PORT
 from esphome.core import EsphomeError
-from esphome.helpers import resolve_ip_address, indent, color
-from esphome.py_compat import text_type, IS_PY2, byte_to_bytes, char_to_byte, format_bytes
+from esphome.helpers import resolve_ip_address, indent
+from esphome.log import color, Fore
 from esphome.util import safe_print
 
 _LOGGER = logging.getLogger(__name__)
@@ -67,16 +67,16 @@ MESSAGE_TYPE_TO_PROTO = {
 
 def _varuint_to_bytes(value):
     if value <= 0x7F:
-        return byte_to_bytes(value)
+        return bytes([value])
 
     ret = bytes()
     while value:
         temp = value & 0x7F
         value >>= 7
         if value:
-            ret += byte_to_bytes(temp | 0x80)
+            ret += bytes([temp | 0x80])
         else:
-            ret += byte_to_bytes(temp)
+            ret += bytes([temp])
 
     return ret
 
@@ -84,8 +84,7 @@ def _varuint_to_bytes(value):
 def _bytes_to_varuint(value):
     result = 0
     bitpos = 0
-    for c in value:
-        val = char_to_byte(c)
+    for val in value:
         result |= (val & 0x7F) << bitpos
         bitpos += 7
         if (val & 0x80) == 0:
@@ -108,7 +107,6 @@ class APIClient(threading.Thread):
         self._message_handlers = []
         self._keepalive = 5
         self._ping_timer = None
-        self._refresh_ping()
 
         self.on_disconnect = None
         self.on_connect = None
@@ -132,8 +130,8 @@ class APIClient(threading.Thread):
             if self._connected:
                 try:
                     self.ping()
-                except APIConnectionError:
-                    self._fatal_error()
+                except APIConnectionError as err:
+                    self._fatal_error(err)
                 else:
                     self._refresh_ping()
 
@@ -175,16 +173,20 @@ class APIClient(threading.Thread):
             raise APIConnectionError("You need to call start() first!")
 
         if self._connected:
-            raise APIConnectionError("Already 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.warning(
+                "Error resolving IP address of %s. Is it connected to WiFi?",
+                self._address,
+            )
+            _LOGGER.warning(
+                "(If this error persists, please set a static IP address: "
+                "https://esphome.io/components/wifi.html#manual-ips)"
+            )
+            raise APIConnectionError(err) from err
 
         _LOGGER.info("Connecting to %s:%s (%s)", self._address, self._port, ip)
         self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -192,30 +194,38 @@ class APIClient(threading.Thread):
         self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
         try:
             self._socket.connect((ip, self._port))
-        except socket.error as err:
-            self._fatal_error()
-            raise APIConnectionError("Error connecting to {}: {}".format(ip, err))
+        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 = 'ESPHome v{}'.format(const.__version__)
+        hello.client_info = f"ESPHome v{const.__version__}"
         try:
             resp = self._send_message_await_response(hello, pb.HelloResponse)
         except APIConnectionError as err:
-            self._fatal_error()
+            self._fatal_error(err)
             raise err
-        _LOGGER.debug("Successfully connected to %s ('%s' API=%s.%s)", self._address,
-                      resp.server_info, resp.api_version_major, resp.api_version_minor)
+        _LOGGER.debug(
+            "Successfully connected to %s ('%s' API=%s.%s)",
+            self._address,
+            resp.server_info,
+            resp.api_version_major,
+            resp.api_version_minor,
+        )
         self._connected = True
+        self._refresh_ping()
         if self.on_connect is not None:
             self.on_connect()
 
     def _check_connected(self):
         if not self._connected:
-            self._fatal_error()
-            raise APIConnectionError("Must be connected!")
+            err = APIConnectionError("Must be connected!")
+            self._fatal_error(err)
+            raise err
 
     def login(self):
         self._check_connected()
@@ -233,25 +243,26 @@ class APIClient(threading.Thread):
         if self.on_login is not None:
             self.on_login()
 
-    def _fatal_error(self):
+    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()
+            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))
+        # _LOGGER.debug("Write: %s", format_bytes(data))
         with self._socket_write_lock:
             try:
                 self._socket.sendall(data)
-            except socket.error as err:
-                self._fatal_error()
-                raise APIConnectionError("Error while writing data: {}".format(err))
+            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
@@ -262,18 +273,16 @@ class APIClient(threading.Thread):
             raise ValueError
 
         encoded = msg.SerializeToString()
-        _LOGGER.debug("Sending %s:\n%s", type(msg), indent(text_type(msg)))
-        if IS_PY2:
-            req = chr(0x00)
-        else:
-            req = bytes([0])
+        _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)
-        self._refresh_ping()
 
-    def _send_message_await_response_complex(self, send_msg, do_append, do_stop, timeout=1):
+    def _send_message_await_response_complex(
+        self, send_msg, do_append, do_stop, timeout=5
+    ):
         event = threading.Event()
         responses = []
 
@@ -294,38 +303,43 @@ class APIClient(threading.Thread):
             raise APIConnectionError("Timeout while waiting for message response!")
         return responses
 
-    def _send_message_await_response(self, send_msg, response_type, timeout=1):
+    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]
+        return self._send_message_await_response_complex(
+            send_msg, is_response, is_response, timeout
+        )[0]
 
     def device_info(self):
         self._check_connected()
-        return self._send_message_await_response(pb.DeviceInfoRequest(), pb.DeviceInfoResponse)
+        return self._send_message_await_response(
+            pb.DeviceInfoRequest(), pb.DeviceInfoResponse
+        )
 
     def ping(self):
         self._check_connected()
         return self._send_message_await_response(pb.PingRequest(), pb.PingResponse)
 
-    def disconnect(self):
+    def disconnect(self, on_disconnect=True):
         self._check_connected()
 
         try:
-            self._send_message_await_response(pb.DisconnectRequest(), pb.DisconnectResponse)
+            self._send_message_await_response(
+                pb.DisconnectRequest(), pb.DisconnectResponse
+            )
         except APIConnectionError:
             pass
         self._close_socket()
 
-        if self.on_disconnect is not None:
-            self.on_disconnect()
+        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=None, dump_config=False):
+    def subscribe_logs(self, on_log, log_level=7, dump_config=False):
         self._check_authenticated()
 
         def on_msg(msg):
@@ -334,8 +348,7 @@ class APIClient(threading.Thread):
 
         self._message_handlers.append(on_msg)
         req = pb.SubscribeLogsRequest(dump_config=dump_config)
-        if log_level is not None:
-            req.level = log_level
+        req.level = log_level
         self._send_message(req)
 
     def _recv(self, amount):
@@ -350,18 +363,18 @@ class APIClient(threading.Thread):
                 raise APIConnectionError("No socket!")
             try:
                 val = self._socket.recv(amount - len(ret))
-            except AttributeError:
-                raise APIConnectionError("Socket was closed")
+            except AttributeError as err:
+                raise APIConnectionError("Socket was closed") from err
             except socket.timeout:
                 continue
-            except socket.error as err:
-                raise APIConnectionError("Error while receiving data: {}".format(err))
+            except OSError as err:
+                raise APIConnectionError(f"Error while receiving data: {err}") from err
             ret += val
         return ret
 
     def _recv_varint(self):
         raw = bytes()
-        while not raw or char_to_byte(raw[-1]) & 0x80:
+        while not raw or raw[-1] & 0x80:
             raw += self._recv(1)
         return _bytes_to_varuint(raw)
 
@@ -370,7 +383,7 @@ class APIClient(threading.Thread):
             return
 
         # Preamble
-        if char_to_byte(self._recv(1)[0]) != 0x00:
+        if self._recv(1)[0] != 0x00:
             raise APIConnectionError("Invalid preamble")
 
         length = self._recv_varint()
@@ -387,7 +400,6 @@ class APIClient(threading.Thread):
         for msg_handler in self._message_handlers[:]:
             msg_handler(msg)
         self._handle_internal_messages(msg)
-        self._refresh_ping()
 
     def run(self):
         self._running_event.set()
@@ -399,7 +411,7 @@ class APIClient(threading.Thread):
                     break
                 if self._connected:
                     _LOGGER.error("Error while reading incoming messages: %s", err)
-                    self._fatal_error()
+                    self._fatal_error(err)
         self._running_event.clear()
 
     def _handle_internal_messages(self, msg):
@@ -410,7 +422,7 @@ class APIClient(threading.Thread):
                 self._socket = None
             self._connected = False
             if self.on_disconnect is not None:
-                self.on_disconnect()
+                self.on_disconnect(None)
         elif isinstance(msg, pb.PingRequest):
             self._send_message(pb.PingResponse())
         elif isinstance(msg, pb.GetTimeRequest):
@@ -420,7 +432,7 @@ class APIClient(threading.Thread):
 
 
 def run_logs(config, address):
-    conf = config['api']
+    conf = config["api"]
     port = conf[CONF_PORT]
     password = conf[CONF_PASSWORD]
     _LOGGER.info("Starting log output from %s using esphome API", address)
@@ -431,12 +443,12 @@ def run_logs(config, address):
 
     has_connects = []
 
-    def try_connect(tries=0, is_disconnect=True):
+    def try_connect(err, tries=0):
         if stopping:
             return
 
-        if is_disconnect:
-            _LOGGER.warning(u"Disconnected from API.")
+        if err:
+            _LOGGER.warning("Disconnected from API: %s", err)
 
         while retry_timer:
             retry_timer.pop(0).cancel()
@@ -445,31 +457,42 @@ def run_logs(config, address):
         try:
             cli.connect()
             cli.login()
-        except APIConnectionError as err:  # noqa
-            error = err
+        except APIConnectionError as err2:  # noqa
+            error = err2
 
         if error is None:
             _LOGGER.info("Successfully connected to %s", address)
             return
 
-        wait_time = min(2**tries, 300)
+        wait_time = int(min(1.5 ** min(tries, 100), 30))
         if not has_connects:
-            _LOGGER.warning(u"Initial connection failed. The ESP might not be connected "
-                            u"to WiFi yet (%s). Re-Trying in %s seconds",
-                            error, wait_time)
+            _LOGGER.warning(
+                "Initial connection failed. The ESP might not be connected "
+                "to WiFi yet (%s). Re-Trying in %s seconds",
+                error,
+                wait_time,
+            )
         else:
-            _LOGGER.warning(u"Couldn't connect to API (%s). Trying to reconnect in %s seconds",
-                            error, wait_time)
-        timer = threading.Timer(wait_time, functools.partial(try_connect, tries + 1, is_disconnect))
+            _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(u'[%H:%M:%S]')
+        time_ = datetime.now().time().strftime("[%H:%M:%S]")
         text = msg.message
         if msg.send_failed:
-            text = color('white', '(Message skipped because it was too big to fit in '
-                                  'TCP buffer - This is only cosmetic)')
+            text = color(
+                Fore.WHITE,
+                "(Message skipped because it was too big to fit in "
+                "TCP buffer - This is only cosmetic)",
+            )
         safe_print(time_ + text)
 
     def on_login():
@@ -484,7 +507,7 @@ def run_logs(config, address):
     cli.start()
 
     try:
-        try_connect(is_disconnect=False)
+        try_connect(None)
         while True:
             time.sleep(1)
     except KeyboardInterrupt:

esphome/automation.py

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

esphome/codegen.py

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

esphome/components/a4988/a4988.cpp

@@ -11,6 +11,7 @@ void A4988::setup() {
   if (this->sleep_pin_ != nullptr) {
     this->sleep_pin_->setup();
     this->sleep_pin_->digital_write(false);
+    this->sleep_pin_state_ = false;
   }
   this->step_pin_->setup();
   this->step_pin_->digital_write(false);
@@ -27,7 +28,12 @@ void A4988::dump_config() {
 void A4988::loop() {
   bool at_target = this->has_reached_target();
   if (this->sleep_pin_ != nullptr) {
+    bool sleep_rising_edge = !sleep_pin_state_ & !at_target;
     this->sleep_pin_->digital_write(!at_target);
+    this->sleep_pin_state_ = !at_target;
+    if (sleep_rising_edge) {
+      delayMicroseconds(1000);
+    }
   }
   if (at_target) {
     this->high_freq_.stop();

esphome/components/a4988/a4988.h

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

esphome/components/a4988/stepper.py

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

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -0,0 +1,217 @@
+#include "ac_dimmer.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP8266
+#include <core_esp8266_waveform.h>
+#endif
+
+namespace esphome {
+namespace ac_dimmer {
+
+static const char *TAG = "ac_dimmer";
+
+// Global array to store dimmer objects
+static AcDimmerDataStore *all_dimmers[32];
+
+/// 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;
+
+/// 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) {
+  // If no ZC signal received yet.
+  if (this->crossed_zero_at == 0)
+    return 0;
+
+  uint32_t time_since_zc = now - this->crossed_zero_at;
+  if (this->value == 65535 || this->value == 0) {
+    return 0;
+  }
+
+  if (this->enable_time_us != 0 && time_since_zc >= this->enable_time_us) {
+    this->enable_time_us = 0;
+    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);
+  }
+  if (this->disable_time_us != 0 && time_since_zc >= this->disable_time_us) {
+    this->disable_time_us = 0;
+    this->gate_pin->digital_write(false);
+  }
+
+  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) {
+    // Next event is disable, return time until that event
+    return this->disable_time_us - time_since_zc;
+  }
+
+  if (time_since_zc >= this->cycle_time_us) {
+    // Already past last cycle time, schedule next call shortly
+    return 100;
+  }
+
+  return this->cycle_time_us - time_since_zc;
+}
+
+/// Run timer interrupt code and return in how many µs the next event is expected
+uint32_t ICACHE_RAM_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)
+      // no more dimmers
+      break;
+    uint32_t res = dimmer->timer_intr(now);
+    if (res != 0 && res < min_dt_us)
+      min_dt_us = res;
+  }
+  // return time until next timer1 interrupt in µs
+  return min_dt_us;
+}
+
+/// GPIO interrupt routine, called when ZC pin triggers
+void ICACHE_RAM_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
+  // in any case the cycle last at least 5ms
+  this->crossed_zero_at = micros();
+  uint32_t cycle_time = this->crossed_zero_at - prev_crossed;
+  if (cycle_time > 5000) {
+    this->cycle_time_us = cycle_time;
+  } else {
+    // Otherwise this is noise and this is 2nd (or 3rd...) fall in the same pulse
+    // Consider this is the right fall edge and accumulate the cycle time instead
+    this->cycle_time_us += cycle_time;
+  }
+
+  if (this->value == 65535) {
+    // fully on, enable output immediately
+    this->gate_pin->digital_write(true);
+  } else if (this->init_cycle) {
+    // send a full cycle
+    this->init_cycle = false;
+    this->enable_time_us = 0;
+    this->disable_time_us = cycle_time_us;
+  } else if (this->value == 0) {
+    // fully off, disable output immediately
+    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);
+    } 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);
+      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);
+      } else {
+        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
+  // 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*.
+  for (auto *dimmer : all_dimmers) {
+    if (dimmer == nullptr)
+      break;
+    if (dimmer->zero_cross_pin_number == store->zero_cross_pin_number) {
+      dimmer->gpio_intr();
+    }
+  }
+}
+
+#ifdef ARDUINO_ARCH_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(); }
+#endif
+
+void AcDimmer::setup() {
+  // extend all_dimmers array with our dimmer
+
+  // Need to be sure the zero cross pin is setup only once, ESP8266 fails and ESP32 seems to fail silently
+  auto setup_zero_cross_pin = true;
+
+  for (auto &all_dimmer : all_dimmers) {
+    if (all_dimmer == nullptr) {
+      all_dimmer = &this->store_;
+      break;
+    }
+    if (all_dimmer->zero_cross_pin_number == this->zero_cross_pin_->get_pin()) {
+      setup_zero_cross_pin = false;
+    }
+  }
+
+  this->gate_pin_->setup();
+  this->store_.gate_pin = this->gate_pin_->to_isr();
+  this->store_.zero_cross_pin_number = this->zero_cross_pin_->get_pin();
+  this->store_.min_power = static_cast<uint16_t>(this->min_power_ * 1000);
+  this->min_power_ = 0;
+  this->store_.method = this->method_;
+
+  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);
+  }
+
+#ifdef ARDUINO_ARCH_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
+  // 80 Divider -> 1 count=1µs
+  dimmer_timer = timerBegin(0, 80, true);
+  timerAttachInterrupt(dimmer_timer, &AcDimmerDataStore::s_timer_intr, true);
+  // For ESP32, we can't use dynamic interval calculation because the timerX functions
+  // are not callable from ISR (placed in flash storage).
+  // Here we just use an interrupt firing every 50 µs.
+  timerAlarmWrite(dimmer_timer, 50, true);
+  timerAlarmEnable(dimmer_timer);
+#endif
+}
+void AcDimmer::write_state(float state) {
+  auto new_value = static_cast<uint16_t>(roundf(state * 65535));
+  if (new_value != 0 && this->store_.value == 0)
+    this->store_.init_cycle = this->init_with_half_cycle_;
+  this->store_.value = new_value;
+}
+void AcDimmer::dump_config() {
+  ESP_LOGCONFIG(TAG, "AcDimmer:");
+  LOG_PIN("  Output Pin: ", this->gate_pin_);
+  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)
+    ESP_LOGCONFIG(TAG, "   Method: leading pulse");
+  else if (method_ == DIM_METHOD_LEADING)
+    ESP_LOGCONFIG(TAG, "   Method: leading");
+  else
+    ESP_LOGCONFIG(TAG, "   Method: trailing");
+
+  LOG_FLOAT_OUTPUT(this);
+  ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
+}
+
+}  // namespace ac_dimmer
+}  // namespace esphome

esphome/components/ac_dimmer/ac_dimmer.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/esphal.h"
+#include "esphome/components/output/float_output.h"
+
+namespace esphome {
+namespace ac_dimmer {
+
+enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
+
+struct AcDimmerDataStore {
+  /// 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;
+  /// Value of the dimmer - 0 to 65535.
+  uint16_t value;
+  /// Minimum power for activation
+  uint16_t min_power;
+  /// Time between the last two ZC pulses
+  uint32_t cycle_time_us;
+  /// Time (in micros()) of last ZC signal
+  uint32_t crossed_zero_at;
+  /// Time since last ZC pulse to enable gate pin. 0 means not set.
+  uint32_t enable_time_us;
+  /// Time since last ZC pulse to disable gate pin. 0 means no disable.
+  uint32_t disable_time_us;
+  /// Set to send the first half ac cycle complete
+  bool init_cycle;
+  /// Dimmer method
+  DimMethod method;
+
+  uint32_t timer_intr(uint32_t now);
+
+  void gpio_intr();
+  static void s_gpio_intr(AcDimmerDataStore *store);
+#ifdef ARDUINO_ARCH_ESP32
+  static void s_timer_intr();
+#endif
+};
+
+class AcDimmer : public output::FloatOutput, public Component {
+ public:
+  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_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_;
+  AcDimmerDataStore store_;
+  bool init_with_half_cycle_;
+  DimMethod method_;
+};
+
+}  // namespace ac_dimmer
+}  // namespace esphome

esphome/components/ac_dimmer/output.py

@@ -0,0 +1,49 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import pins
+from esphome.components import output
+from esphome.const import CONF_ID, CONF_MIN_POWER, CONF_METHOD
+
+CODEOWNERS = ["@glmnet"]
+
+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")
+DIM_METHODS = {
+    "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)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    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
+    await output.register_output(var, config)
+
+    pin = await cg.gpio_pin_expression(config[CONF_GATE_PIN])
+    cg.add(var.set_gate_pin(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

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import uart
+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"]
+
+adalight_ns = cg.esphome_ns.namespace("adalight")
+AdalightLightEffect = adalight_ns.class_(
+    "AdalightLightEffect", uart.UARTDevice, AddressableLightEffect
+)
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+@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])
+    await uart.register_uart_device(effect, config)
+    return effect

esphome/components/adalight/adalight_light_effect.cpp

@@ -0,0 +1,140 @@
+#include "adalight_light_effect.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace adalight {
+
+static const char *TAG = "adalight_light_effect";
+
+static const uint32_t ADALIGHT_ACK_INTERVAL = 1000;
+static const uint32_t ADALIGHT_RECEIVE_TIMEOUT = 1000;
+
+AdalightLightEffect::AdalightLightEffect(const std::string &name) : AddressableLightEffect(name) {}
+
+void AdalightLightEffect::start() {
+  AddressableLightEffect::start();
+
+  last_ack_ = 0;
+  last_byte_ = 0;
+  last_reset_ = 0;
+}
+
+void AdalightLightEffect::stop() {
+  frame_.resize(0);
+
+  AddressableLightEffect::stop();
+}
+
+int AdalightLightEffect::get_frame_size_(int led_count) const {
+  // 3 bytes: Ada
+  // 2 bytes: LED count
+  // 1 byte: checksum
+  // 3 bytes per LED
+  return 3 + 2 + 1 + led_count * 3;
+}
+
+void AdalightLightEffect::reset_frame_(light::AddressableLight &it) {
+  int buffer_capacity = get_frame_size_(it.size());
+
+  frame_.clear();
+  frame_.reserve(buffer_capacity);
+}
+
+void AdalightLightEffect::blank_all_leds_(light::AddressableLight &it) {
+  for (int led = it.size(); led-- > 0;) {
+    it[led].set(COLOR_BLACK);
+  }
+}
+
+void AdalightLightEffect::apply(light::AddressableLight &it, const Color &current_color) {
+  const uint32_t now = millis();
+
+  if (now - this->last_ack_ >= ADALIGHT_ACK_INTERVAL) {
+    ESP_LOGV(TAG, "Sending ACK");
+    this->write_str("Ada\n");
+    this->last_ack_ = now;
+  }
+
+  if (!this->last_reset_) {
+    ESP_LOGW(TAG, "Frame: Reset.");
+    reset_frame_(it);
+    blank_all_leds_(it);
+    this->last_reset_ = now;
+  }
+
+  if (!this->frame_.empty() && now - this->last_byte_ >= ADALIGHT_RECEIVE_TIMEOUT) {
+    ESP_LOGW(TAG, "Frame: Receive timeout (size=%zu).", this->frame_.size());
+    reset_frame_(it);
+    blank_all_leds_(it);
+  }
+
+  if (this->available() > 0) {
+    ESP_LOGV(TAG, "Frame: Available (size=%d).", this->available());
+  }
+
+  while (this->available() != 0) {
+    uint8_t data;
+    if (!this->read_byte(&data))
+      break;
+    this->frame_.push_back(data);
+    this->last_byte_ = now;
+
+    switch (this->parse_frame_(it)) {
+      case INVALID:
+        ESP_LOGD(TAG, "Frame: Invalid (size=%zu, first=%d).", this->frame_.size(), this->frame_[0]);
+        reset_frame_(it);
+        break;
+
+      case PARTIAL:
+        break;
+
+      case CONSUMED:
+        ESP_LOGV(TAG, "Frame: Consumed (size=%zu).", this->frame_.size());
+        reset_frame_(it);
+        break;
+    }
+  }
+}
+
+AdalightLightEffect::Frame AdalightLightEffect::parse_frame_(light::AddressableLight &it) {
+  if (frame_.empty())
+    return INVALID;
+
+  // Check header: `Ada`
+  if (frame_[0] != 'A')
+    return INVALID;
+  if (frame_.size() > 1 && frame_[1] != 'd')
+    return INVALID;
+  if (frame_.size() > 2 && frame_[2] != 'a')
+    return INVALID;
+
+  // 3 bytes: Count Hi, Count Lo, Checksum
+  if (frame_.size() < 6)
+    return PARTIAL;
+
+  // Check checksum
+  uint16_t checksum = frame_[3] ^ frame_[4] ^ 0x55;
+  if (checksum != frame_[5])
+    return INVALID;
+
+  // Check if we received the full frame
+  uint16_t led_count = (frame_[3] << 8) + frame_[4] + 1;
+  auto buffer_size = get_frame_size_(led_count);
+  if (frame_.size() < buffer_size)
+    return PARTIAL;
+
+  // Apply lights
+  auto accepted_led_count = std::min<int>(led_count, it.size());
+  uint8_t *led_data = &frame_[6];
+
+  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(Color(led_data[0], led_data[1], led_data[2], white));
+  }
+
+  return CONSUMED;
+}
+
+}  // namespace adalight
+}  // namespace esphome

esphome/components/adalight/adalight_light_effect.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/light/addressable_light_effect.h"
+#include "esphome/components/uart/uart.h"
+
+#include <vector>
+
+namespace esphome {
+namespace adalight {
+
+class AdalightLightEffect : public light::AddressableLightEffect, public uart::UARTDevice {
+ public:
+  AdalightLightEffect(const std::string &name);
+
+ public:
+  void start() override;
+  void stop() override;
+  void apply(light::AddressableLight &it, const Color &current_color) override;
+
+ protected:
+  enum Frame {
+    INVALID,
+    PARTIAL,
+    CONSUMED,
+  };
+
+  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};
+  std::vector<uint8_t> frame_;
+};
+
+}  // namespace adalight
+}  // namespace esphome

esphome/components/adc/__init__.py

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

esphome/components/adc/adc_sensor.cpp

@@ -16,7 +16,9 @@ void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuati
 
 void ADCSensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
+#ifndef USE_ADC_SENSOR_VCC
   GPIOPin(this->pin_, INPUT).setup();
+#endif
 
 #ifdef ARDUINO_ARCH_ESP32
   analogSetPinAttenuation(this->pin_, this->attenuation_);
@@ -58,7 +60,7 @@ void ADCSensor::update() {
 }
 float ADCSensor::sample() {
 #ifdef ARDUINO_ARCH_ESP32
-  float value_v = analogRead(this->pin_) / 4095.0f;
+  float value_v = analogRead(this->pin_) / 4095.0f;  // NOLINT
   switch (this->attenuation_) {
     case ADC_0db:
       value_v *= 1.1;
@@ -80,7 +82,7 @@ float ADCSensor::sample() {
 #ifdef USE_ADC_SENSOR_VCC
   return ESP.getVcc() / 1024.0f;
 #else
-  return analogRead(this->pin_) / 1024.0f;
+  return analogRead(this->pin_) / 1024.0f;  // NOLINT
 #endif
 #endif
 }

esphome/components/adc/sensor.py

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

esphome/components/addressable_light/addressable_light_display.cpp

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

esphome/components/addressable_light/addressable_light_display.h

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

esphome/components/addressable_light/display.py

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

esphome/components/ade7953/ade7953.cpp

@@ -0,0 +1,54 @@
+#include "ade7953.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace ade7953 {
+
+static const char *TAG = "ade7953";
+
+void ADE7953::dump_config() {
+  ESP_LOGCONFIG(TAG, "ADE7953:");
+  if (this->has_irq_) {
+    ESP_LOGCONFIG(TAG, "  IRQ Pin: GPIO%u", this->irq_pin_number_);
+  }
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Voltage Sensor", this->voltage_sensor_);
+  LOG_SENSOR("  ", "Current A Sensor", this->current_a_sensor_);
+  LOG_SENSOR("  ", "Current B Sensor", this->current_b_sensor_);
+  LOG_SENSOR("  ", "Active Power A Sensor", this->active_power_a_sensor_);
+  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; \
+    this->name##_sensor_->publish_state(value); \
+  }
+#define ADE_PUBLISH(name, factor) ADE_PUBLISH_(name, 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);
+
+  //    auto apparent_power_a = this->ade_read_<int32_t>(0x0310);
+  //    auto apparent_power_b = this->ade_read_<int32_t>(0x0311);
+  //    auto reactive_power_a = this->ade_read_<int32_t>(0x0314);
+  //    auto reactive_power_b = this->ade_read_<int32_t>(0x0315);
+  //    auto power_factor_a = this->ade_read_<int16_t>(0x010A);
+  //    auto power_factor_b = this->ade_read_<int16_t>(0x010B);
+}
+
+}  // namespace ade7953
+}  // namespace esphome

esphome/components/ade7953/ade7953.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome {
+namespace ade7953 {
+
+class ADE7953 : public i2c::I2CDevice, public PollingComponent {
+ public:
+  void set_irq_pin(uint8_t irq_pin) {
+    has_irq_ = true;
+    irq_pin_number_ = irq_pin;
+  }
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
+  void set_current_a_sensor(sensor::Sensor *current_a_sensor) { current_a_sensor_ = current_a_sensor; }
+  void set_current_b_sensor(sensor::Sensor *current_b_sensor) { current_b_sensor_ = current_b_sensor; }
+  void set_active_power_a_sensor(sensor::Sensor *active_power_a_sensor) {
+    active_power_a_sensor_ = active_power_a_sensor;
+  }
+  void set_active_power_b_sensor(sensor::Sensor *active_power_b_sensor) {
+    active_power_b_sensor_ = active_power_b_sensor;
+  }
+
+  void setup() override {
+    if (this->has_irq_) {
+      auto pin = GPIOPin(this->irq_pin_number_, INPUT);
+      this->irq_pin_ = &pin;
+      this->irq_pin_->setup();
+    }
+    this->set_timeout(100, [this]() {
+      this->ade_write_<uint8_t>(0x0010, 0x04);
+      this->ade_write_<uint8_t>(0x00FE, 0xAD);
+      this->ade_write_<uint16_t>(0x0120, 0x0030);
+      this->is_setup_ = true;
+    });
+  }
+
+  void dump_config() override;
+
+  void update() override;
+
+ protected:
+  template<typename T> bool ade_write_(uint16_t reg, 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);
+  }
+  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;
+  }
+
+  bool has_irq_ = false;
+  uint8_t irq_pin_number_;
+  GPIOPin *irq_pin_{nullptr};
+  bool is_setup_{false};
+  sensor::Sensor *voltage_sensor_{nullptr};
+  sensor::Sensor *current_a_sensor_{nullptr};
+  sensor::Sensor *current_b_sensor_{nullptr};
+  sensor::Sensor *active_power_a_sensor_{nullptr};
+  sensor::Sensor *active_power_b_sensor_{nullptr};
+};
+
+}  // namespace ade7953
+}  // namespace esphome

esphome/components/ade7953/sensor.py

@@ -0,0 +1,83 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, i2c
+from esphome import pins
+from esphome.const import (
+    CONF_ID,
+    CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+)
+
+DEPENDENCIES = ["i2c"]
+
+ade7953_ns = cg.esphome_ns.namespace("ade7953")
+ADE7953 = ade7953_ns.class_("ADE7953", cg.PollingComponent, i2c.I2CDevice)
+
+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_IRQ_PIN): pins.input_pin,
+            cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(
+                UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE, STATE_CLASS_MEASUREMENT
+            ),
+            cv.Optional(CONF_CURRENT_A): sensor.sensor_schema(
+                UNIT_AMPERE,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_CURRENT,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CURRENT_B): sensor.sensor_schema(
+                UNIT_AMPERE,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_CURRENT,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_A): sensor.sensor_schema(
+                UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+            ),
+            cv.Optional(CONF_ACTIVE_POWER_B): sensor.sensor_schema(
+                UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if CONF_IRQ_PIN in config:
+        cg.add(var.set_irq_pin(config[CONF_IRQ_PIN]))
+
+    for key in [
+        CONF_VOLTAGE,
+        CONF_CURRENT_A,
+        CONF_CURRENT_B,
+        CONF_ACTIVE_POWER_A,
+        CONF_ACTIVE_POWER_B,
+    ]:
+        if key not in config:
+            continue
+        conf = config[key]
+        sens = await sensor.new_sensor(conf)
+        cg.add(getattr(var, f"set_{key}_sensor")(sens))

esphome/components/ads1115/__init__.py

@@ -3,19 +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)
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(ADS1115Component),
-}).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

@@ -29,9 +29,15 @@ void ADS1115Component::setup() {
   //        0bxxxx000xxxxxxxxx
   config |= ADS1115_GAIN_6P144 << 9;
 
-  // Set singleshot mode
-  //        0bxxxxxxx1xxxxxxxx
-  config |= 0b0000000100000000;
+  if (this->continuous_mode_) {
+    // Set continuous mode
+    //        0bxxxxxxx0xxxxxxxx
+    config |= 0b0000000000000000;
+  } else {
+    // Set singleshot mode
+    //        0bxxxxxxx1xxxxxxxx
+    config |= 0b0000000100000000;
+  }
 
   // Set data rate - 860 samples per second (we're in singleshot mode)
   //        0bxxxxxxxx100xxxxx
@@ -57,6 +63,8 @@ void ADS1115Component::setup() {
     this->mark_failed();
     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); });
@@ -75,13 +83,8 @@ void ADS1115Component::dump_config() {
     ESP_LOGCONFIG(TAG, "    Gain: %u", sensor->get_gain());
   }
 }
-float ADS1115Component::get_setup_priority() const { return setup_priority::DATA; }
 float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
-  uint16_t config;
-  if (!this->read_byte_16(ADS1115_REGISTER_CONFIG, &config)) {
-    this->status_set_warning();
-    return NAN;
-  }
+  uint16_t config = this->prev_config_;
   // Multiplexer
   //        0bxBBBxxxxxxxxxxxx
   config &= 0b1000111111111111;
@@ -91,25 +94,31 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
   //        0bxxxxBBBxxxxxxxxx
   config &= 0b1111000111111111;
   config |= (sensor->get_gain() & 0b111) << 9;
-  // Start conversion
-  config |= 0b1000000000000000;
 
-  if (!this->write_byte_16(ADS1115_REGISTER_CONFIG, config)) {
-    this->status_set_warning();
-    return NAN;
+  if (!this->continuous_mode_) {
+    // Start conversion
+    config |= 0b1000000000000000;
   }
 
-  // about 1.6 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");
+  if (!this->continuous_mode_ || this->prev_config_ != config) {
+    if (!this->write_byte_16(ADS1115_REGISTER_CONFIG, config)) {
       this->status_set_warning();
       return NAN;
     }
-    yield();
+    this->prev_config_ = config;
+
+    // about 1.6 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;
+      }
+      yield();
+    }
   }
 
   uint16_t raw_conversion;
@@ -144,13 +153,9 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
   }
 
   this->status_clear_warning();
-  return millivolts / 1e4f;
+  return millivolts / 1e3f;
 }
 
-uint8_t ADS1115Sensor::get_multiplexer() const { return this->multiplexer_; }
-void ADS1115Sensor::set_multiplexer(ADS1115Multiplexer multiplexer) { this->multiplexer_ = multiplexer; }
-uint8_t ADS1115Sensor::get_gain() const { return this->gain_; }
-void ADS1115Sensor::set_gain(ADS1115Gain gain) { this->gain_ = gain; }
 float ADS1115Sensor::sample() { return this->parent_->request_measurement(this); }
 void ADS1115Sensor::update() {
   float v = this->parent_->request_measurement(this);

esphome/components/ads1115/ads1115.h

@@ -37,13 +37,16 @@ class ADS1115Component : public Component, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
   /// HARDWARE_LATE setup priority
-  float get_setup_priority() const override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_continuous_mode(bool continuous_mode) { continuous_mode_ = continuous_mode; }
 
   /// Helper method to request a measurement from a sensor.
   float request_measurement(ADS1115Sensor *sensor);
 
  protected:
   std::vector<ADS1115Sensor *> sensors_;
+  uint16_t prev_config_{0};
+  bool continuous_mode_;
 };
 
 /// Internal holder class that is in instance of Sensor so that the hub can create individual sensors.
@@ -51,12 +54,12 @@ class ADS1115Sensor : public sensor::Sensor, public PollingComponent, public vol
  public:
   ADS1115Sensor(ADS1115Component *parent) : parent_(parent) {}
   void update() override;
-  void set_multiplexer(ADS1115Multiplexer multiplexer);
-  void set_gain(ADS1115Gain gain);
+  void set_multiplexer(ADS1115Multiplexer multiplexer) { multiplexer_ = multiplexer; }
+  void set_gain(ADS1115Gain gain) { gain_ = gain; }
 
   float sample() override;
-  uint8_t get_multiplexer() const;
-  uint8_t get_gain() const;
+  uint8_t get_multiplexer() const { return multiplexer_; }
+  uint8_t get_gain() const { return gain_; }
 
  protected:
   ADS1115Component *parent_;

esphome/components/ads1115/sensor.py

@@ -1,61 +1,77 @@
 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.py_compat import string_types
+from esphome.const import (
+    CONF_GAIN,
+    CONF_MULTIPLEXER,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    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 = u'{:0.03f}'.format(value)
-    elif not isinstance(value, string_types):
-        raise cv.Invalid('invalid gain "{}"'.format(value))
+        value = f"{value:0.03f}"
+    elif not isinstance(value, str):
+        raise cv.Invalid(f'invalid gain "{value}"')
 
     return cv.enum(GAIN)(value)
 
 
-ADS1115Sensor = ads1115_ns.class_('ADS1115Sensor', sensor.Sensor, cg.PollingComponent,
-                                  voltage_sampler.VoltageSampler)
+ADS1115Sensor = ads1115_ns.class_(
+    "ADS1115Sensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
+)
 
-CONF_ADS1115_ID = 'ads1115_id'
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 3).extend({
-    cv.GenerateID(): cv.declare_id(ADS1115Sensor),
-    cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
-    cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space='_'),
-    cv.Required(CONF_GAIN): validate_gain,
-}).extend(cv.polling_component_schema('60s'))
+CONF_ADS1115_ID = "ads1115_id"
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        UNIT_VOLT, ICON_EMPTY, 3, DEVICE_CLASS_VOLTAGE, STATE_CLASS_MEASUREMENT
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(ADS1115Sensor),
+            cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
+            cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space="_"),
+            cv.Required(CONF_GAIN): validate_gain,
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+)
 
 
-def to_code(config):
-    paren = yield cg.get_variable(config[CONF_ADS1115_ID])
+async def to_code(config):
+    paren = await cg.get_variable(config[CONF_ADS1115_ID])
     var = cg.new_Pvariable(config[CONF_ID], paren)
-    yield sensor.register_sensor(var, config)
-    yield cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
 
     cg.add(var.set_multiplexer(config[CONF_MULTIPLEXER]))
     cg.add(var.set_gain(config[CONF_GAIN]))

esphome/components/aht10/aht10.cpp

@@ -0,0 +1,128 @@
+// Implementation based on:
+//  - AHT10: https://github.com/Thinary/AHT10
+//  - Official Datasheet (cn):
+//  http://www.aosong.com/userfiles/files/media/aht10%E8%A7%84%E6%A0%BC%E4%B9%A6v1_1%EF%BC%8820191015%EF%BC%89.pdf
+//  - Unofficial Translated Datasheet (en):
+//  https://wiki.liutyi.info/download/attachments/30507639/Aosong_AHT10_en_draft_0c.pdf
+//
+// When configured for humidity, the log 'Components should block for at most 20-30ms in loop().' will be generated in
+// verbose mode. This is due to technical specs of the sensor and can not be avoided.
+//
+// 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.
+
+#include "aht10.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace aht10 {
+
+static const char *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
+
+void AHT10Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up AHT10...");
+
+  if (!this->write_bytes(0, AHT10_CALIBRATE_CMD, sizeof(AHT10_CALIBRATE_CMD))) {
+    ESP_LOGE(TAG, "Communication with AHT10 failed!");
+    this->mark_failed();
+    return;
+  }
+  uint8_t data;
+  if (!this->read_byte(0, &data, AHT10_DEFAULT_DELAY)) {
+    ESP_LOGD(TAG, "Communication with AHT10 failed!");
+    this->mark_failed();
+    return;
+  }
+  if ((data & 0x68) != 0x08) {  // Bit[6:5] = 0b00, NORMAL mode and Bit[3] = 0b1, CALIBRATED
+    ESP_LOGE(TAG, "AHT10 calibration failed!");
+    this->mark_failed();
+    return;
+  }
+
+  ESP_LOGV(TAG, "AHT10 calibrated");
+}
+
+void AHT10Component::update() {
+  if (!this->write_bytes(0, AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD))) {
+    ESP_LOGE(TAG, "Communication with AHT10 failed!");
+    this->status_set_warning();
+    return;
+  }
+  uint8_t data[6];
+  uint8_t delay = AHT10_DEFAULT_DELAY;
+  if (this->humidity_sensor_ != nullptr)
+    delay = AHT10_HUMIDITY_DELAY;
+  for (int i = 0; i < AHT10_ATTEMPS; ++i) {
+    ESP_LOGVV(TAG, "Attemps %u at %6ld", i, millis());
+    delay_microseconds_accurate(4);
+    if (!this->read_bytes(0, data, 6, delay)) {
+      ESP_LOGD(TAG, "Communication with AHT10 failed, waiting...");
+    } else if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy
+      ESP_LOGD(TAG, "AHT10 is busy, waiting...");
+    } else if (data[1] == 0x0 && data[2] == 0x0 && (data[3] >> 4) == 0x0) {
+      // Unrealistic humidity (0x0)
+      if (this->humidity_sensor_ == nullptr) {
+        ESP_LOGVV(TAG, "ATH10 Unrealistic humidity (0x0), but humidity is not required");
+        break;
+      } else {
+        ESP_LOGD(TAG, "ATH10 Unrealistic humidity (0x0), retrying...");
+        if (!this->write_bytes(0, AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD))) {
+          ESP_LOGE(TAG, "Communication with AHT10 failed!");
+          this->status_set_warning();
+          return;
+        }
+      }
+    } else {
+      // data is valid, we can break the loop
+      ESP_LOGVV(TAG, "Answer at %6ld", millis());
+      break;
+    }
+  }
+  if ((data[0] & 0x80) == 0x80) {
+    ESP_LOGE(TAG, "Measurements reading timed-out!");
+    this->status_set_warning();
+    return;
+  }
+
+  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 humidity;
+  if (raw_humidity == 0) {  // unrealistic value
+    humidity = NAN;
+  } else {
+    humidity = (float) raw_humidity * 100.0 / 1048576.0;
+  }
+
+  if (this->temperature_sensor_ != nullptr) {
+    this->temperature_sensor_->publish_state(temperature);
+  }
+  if (this->humidity_sensor_ != nullptr) {
+    if (isnan(humidity))
+      ESP_LOGW(TAG, "Invalid humidity! Sensor reported 0%% Hum");
+    this->humidity_sensor_->publish_state(humidity);
+  }
+  this->status_clear_warning();
+}
+
+float AHT10Component::get_setup_priority() const { return setup_priority::DATA; }
+
+void AHT10Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "AHT10:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with AHT10 failed!");
+  }
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+}
+
+}  // namespace aht10
+}  // namespace esphome

esphome/components/aht10/aht10.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace aht10 {
+
+class AHT10Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+
+  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
+
+ protected:
+  sensor::Sensor *temperature_sensor_;
+  sensor::Sensor *humidity_sensor_;
+};
+
+}  // namespace aht10
+}  // namespace esphome

esphome/components/aht10/sensor.py

@@ -0,0 +1,57 @@
+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,
+    DEVICE_CLASS_HUMIDITY,
+    DEVICE_CLASS_TEMPERATURE,
+    ICON_EMPTY,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+    UNIT_PERCENT,
+)
+
+DEPENDENCIES = ["i2c"]
+
+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_EMPTY,
+                2,
+                DEVICE_CLASS_TEMPERATURE,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                UNIT_PERCENT,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_HUMIDITY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x38))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity_sensor(sens))

esphome/components/am2320/sensor.py

@@ -1,30 +1,59 @@
 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,
+    ICON_EMPTY,
+    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_CELSIUS,
+                ICON_EMPTY,
+                1,
+                DEVICE_CLASS_TEMPERATURE,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
+                UNIT_PERCENT,
+                ICON_EMPTY,
+                1,
+                DEVICE_CLASS_HUMIDITY,
+                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/animation/__init__.py

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

esphome/components/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/binary_sensor.py

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

esphome/components/apds9960/sensor.py

@@ -1,27 +1,37 @@
 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,
+    DEVICE_CLASS_EMPTY,
+    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_PERCENT, ICON_LIGHTBULB, 1, DEVICE_CLASS_EMPTY, STATE_CLASS_MEASUREMENT
+).extend(
+    {
+        cv.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+        cv.GenerateID(CONF_APDS9960_ID): cv.use_id(APDS9960),
+    }
+)
 
 
-def to_code(config):
-    hub = yield cg.get_variable(config[CONF_APDS9960_ID])
-    var = yield sensor.new_sensor(config)
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_APDS9960_ID])
+    var = await sensor.new_sensor(config)
     func = getattr(hub, TYPES[config[CONF_TYPE]])
     cg.add(func(var))

esphome/components/api/__init__.py

@@ -2,54 +2,75 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import automation
 from esphome.automation import Condition
-from esphome.const import CONF_DATA, CONF_DATA_TEMPLATE, CONF_ID, CONF_PASSWORD, CONF_PORT, \
-    CONF_REBOOT_TIMEOUT, CONF_SERVICE, CONF_VARIABLES, CONF_SERVICES, CONF_TRIGGER_ID
-from esphome.core import CORE, coroutine_with_priority
+from esphome.const import (
+    CONF_DATA,
+    CONF_DATA_TEMPLATE,
+    CONF_ID,
+    CONF_PASSWORD,
+    CONF_PORT,
+    CONF_REBOOT_TIMEOUT,
+    CONF_SERVICE,
+    CONF_VARIABLES,
+    CONF_SERVICES,
+    CONF_TRIGGER_ID,
+    CONF_EVENT,
+    CONF_TAG,
+)
+from esphome.core import coroutine_with_priority
 
-DEPENDENCIES = ['network']
+DEPENDENCIES = ["network"]
+AUTO_LOAD = ["async_tcp"]
+CODEOWNERS = ["@OttoWinter"]
 
-api_ns = cg.esphome_ns.namespace('api')
-APIServer = api_ns.class_('APIServer', cg.Component, cg.Controller)
-HomeAssistantServiceCallAction = api_ns.class_('HomeAssistantServiceCallAction', automation.Action)
-KeyValuePair = api_ns.class_('KeyValuePair')
-TemplatableKeyValuePair = api_ns.class_('TemplatableKeyValuePair')
-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)
 
-UserService = api_ns.class_('UserService', automation.Trigger)
-ServiceTypeArgument = api_ns.class_('ServiceTypeArgument')
-ServiceArgType = api_ns.enum('ServiceArgType')
-SERVICE_ARG_TYPES = {
-    'bool': ServiceArgType.SERVICE_ARG_TYPE_BOOL,
-    'int': ServiceArgType.SERVICE_ARG_TYPE_INT,
-    'float': ServiceArgType.SERVICE_ARG_TYPE_FLOAT,
-    'string': ServiceArgType.SERVICE_ARG_TYPE_STRING,
-}
+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": bool,
+    "int": cg.int32,
+    "float": float,
+    "string": cg.std_string,
+    "bool[]": cg.std_vector.template(bool),
+    "int[]": cg.std_vector.template(cg.int32),
+    "float[]": cg.std_vector.template(float),
+    "string[]": cg.std_vector.template(cg.std_string),
 }
 
-CONFIG_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.declare_id(APIServer),
-    cv.Optional(CONF_PORT, default=6053): cv.port,
-    cv.Optional(CONF_PASSWORD, default=''): cv.string_strict,
-    cv.Optional(CONF_REBOOT_TIMEOUT, default='5min'): cv.positive_time_period_milliseconds,
-    cv.Optional(CONF_SERVICES): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserService),
-        cv.Required(CONF_SERVICE): cv.valid_name,
-        cv.Optional(CONF_VARIABLES, default={}): cv.Schema({
-            cv.validate_id_name: cv.one_of(*SERVICE_ARG_TYPES, lower=True),
-        }),
-    }),
-}).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(APIServer),
+        cv.Optional(CONF_PORT, default=6053): cv.port,
+        cv.Optional(CONF_PASSWORD, default=""): cv.string_strict,
+        cv.Optional(
+            CONF_REBOOT_TIMEOUT, default="15min"
+        ): cv.positive_time_period_milliseconds,
+        cv.Optional(CONF_SERVICES): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UserServiceTrigger),
+                cv.Required(CONF_SERVICE): cv.valid_name,
+                cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+                    {
+                        cv.validate_id_name: cv.one_of(
+                            *SERVICE_ARG_NATIVE_TYPES, lower=True
+                        ),
+                    }
+                ),
+            }
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
 
 
 @coroutine_with_priority(40.0)
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
+    await cg.register_component(var, config)
 
     cg.add(var.set_port(config[CONF_PORT]))
     cg.add(var.set_password(config[CONF_PASSWORD]))
@@ -58,61 +79,126 @@ def to_code(config):
     for conf in config.get(CONF_SERVICES, []):
         template_args = []
         func_args = []
-        service_type_args = []
+        service_arg_names = []
         for name, var_ in conf[CONF_VARIABLES].items():
             native = SERVICE_ARG_NATIVE_TYPES[var_]
             template_args.append(native)
             func_args.append((native, name))
-            service_type_args.append(ServiceTypeArgument(name, SERVICE_ARG_TYPES[var_]))
+            service_arg_names.append(name)
         templ = cg.TemplateArguments(*template_args)
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], templ,
-                                   conf[CONF_SERVICE], service_type_args)
+        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 CORE.is_esp32:
-        cg.add_library('AsyncTCP', '1.0.3')
-    elif CORE.is_esp8266:
-        cg.add_library('ESPAsyncTCP', '1.2.0')
+    cg.add_define("USE_API")
+    cg.add_global(api_ns.using)
 
 
-HOMEASSISTANT_SERVICE_ACTION_SCHEMA = cv.Schema({
-    cv.GenerateID(): cv.use_id(APIServer),
-    cv.Required(CONF_SERVICE): cv.string,
-    cv.Optional(CONF_DATA): cv.Schema({
-        cv.string: cv.string,
-    }),
-    cv.Optional(CONF_DATA_TEMPLATE): cv.Schema({
-        cv.string: cv.string,
-    }),
-    cv.Optional(CONF_VARIABLES): cv.Schema({
-        cv.string: cv.returning_lambda,
-    }),
-})
+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}
+        ),
+    }
+)
 
 
-@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])
-    var = cg.new_Pvariable(action_id, template_arg, serv)
-    cg.add(var.set_service(config[CONF_SERVICE]))
-    if CONF_DATA in config:
-        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA].items()]
-        cg.add(var.set_data(datas))
-    if CONF_DATA_TEMPLATE in config:
-        datas = [KeyValuePair(k, v) for k, v in config[CONF_DATA_TEMPLATE].items()]
-        cg.add(var.set_data_template(datas))
-    if CONF_VARIABLES in config:
-        datas = []
-        for key, value in config[CONF_VARIABLES].items():
-            value_ = yield cg.process_lambda(value, [])
-            datas.append(TemplatableKeyValuePair(key, value_))
-        cg.add(var.set_variables(datas))
-    yield var
+@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 = await cg.templatable(config[CONF_SERVICE], args, None)
+    cg.add(var.set_service(templ))
+    for key, value in config[CONF_DATA].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
+    for key, value in config[CONF_DATA_TEMPLATE].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
+    for key, value in config[CONF_VARIABLES].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
+    return var
 
 
-@automation.register_condition('api.connected', APIConnectedCondition, {})
-def api_connected_to_code(config, condition_id, template_arg, args):
-    yield cg.new_Pvariable(condition_id, template_arg)
+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'"
+        )
+    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,
+    }
+)
+
+
+@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 = await cg.templatable(config[CONF_EVENT], args, None)
+    cg.add(var.set_service(templ))
+    for key, value in config[CONF_DATA].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
+    for key, value in config[CONF_DATA_TEMPLATE].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
+    for key, value in config[CONF_VARIABLES].items():
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
+    return var
+
+
+HOMEASSISTANT_TAG_SCANNED_ACTION_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.GenerateID(): cv.use_id(APIServer),
+        cv.Required(CONF_TAG): cv.templatable(cv.string_strict),
+    },
+    key=CONF_TAG,
+)
+
+
+@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

@@ -1,11 +1,52 @@
 syntax = "proto3";
 
+import "api_options.proto";
+
+service APIConnection {
+  rpc hello (HelloRequest) returns (HelloResponse) {
+    option (needs_setup_connection) = false;
+    option (needs_authentication) = false;
+  }
+  rpc connect (ConnectRequest) returns (ConnectResponse) {
+    option (needs_setup_connection) = false;
+    option (needs_authentication) = false;
+  }
+  rpc disconnect (DisconnectRequest) returns (DisconnectResponse) {
+    option (needs_setup_connection) = false;
+    option (needs_authentication) = false;
+  }
+  rpc ping (PingRequest) returns (PingResponse) {
+    option (needs_setup_connection) = false;
+    option (needs_authentication) = false;
+  }
+  rpc device_info (DeviceInfoRequest) returns (DeviceInfoResponse) {
+    option (needs_authentication) = false;
+  }
+  rpc list_entities (ListEntitiesRequest) returns (void) {}
+  rpc subscribe_states (SubscribeStatesRequest) returns (void) {}
+  rpc subscribe_logs (SubscribeLogsRequest) returns (void) {}
+  rpc subscribe_homeassistant_services (SubscribeHomeassistantServicesRequest) returns (void) {}
+  rpc subscribe_home_assistant_states (SubscribeHomeAssistantStatesRequest) returns (void) {}
+  rpc get_time (GetTimeRequest) returns (GetTimeResponse) {
+    option (needs_authentication) = false;
+  }
+  rpc execute_service (ExecuteServiceRequest) returns (void) {}
+
+  rpc cover_command (CoverCommandRequest) returns (void) {}
+  rpc fan_command (FanCommandRequest) returns (void) {}
+  rpc light_command (LightCommandRequest) returns (void) {}
+  rpc switch_command (SwitchCommandRequest) returns (void) {}
+  rpc camera_image (CameraImageRequest) returns (void) {}
+  rpc climate_command (ClimateCommandRequest) returns (void) {}
+}
+
 
 // ==================== BASE PACKETS ====================
 
 // 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
@@ -21,8 +62,11 @@ syntax = "proto3";
 
 // Message sent at the beginning of each connection
 // Can only be sent by the client and only at the beginning of the connection
-// ID: 1
 message HelloRequest {
+  option (id) = 1;
+  option (source) = SOURCE_CLIENT;
+  option (no_delay) = true;
+
   // Description of client (like User Agent)
   // For example "Home Assistant"
   // Not strictly necessary to send but nice for debugging
@@ -32,8 +76,11 @@ message HelloRequest {
 
 // Confirmation of successful connection request.
 // Can only be sent by the server and only at the beginning of the connection
-// ID: 2
 message HelloResponse {
+  option (id) = 2;
+  option (source) = SOURCE_SERVER;
+  option (no_delay) = true;
+
   // The version of the API to use. The _client_ (for example Home Assistant) needs to check
   // for compatibility and if necessary adopt to an older API.
   // Major is for breaking changes in the base protocol - a mismatch will lead to immediate disconnect_client_
@@ -49,49 +96,66 @@ message HelloResponse {
 
 // Message sent at the beginning of each connection to authenticate the client
 // Can only be sent by the client and only at the beginning of the connection
-// ID: 3
 message ConnectRequest {
+  option (id) = 3;
+  option (source) = SOURCE_CLIENT;
+  option (no_delay) = true;
+
   // The password to log in with
   string password = 1;
 }
 
 // Confirmation of successful connection. After this the connection is available for all traffic.
 // Can only be sent by the server and only at the beginning of the connection
-// ID: 4
 message ConnectResponse {
+  option (id) = 4;
+  option (source) = SOURCE_SERVER;
+  option (no_delay) = true;
+
   bool invalid_password = 1;
 }
 
 // Request to close the connection.
 // Can be sent by both the client and server
-// ID: 5
 message DisconnectRequest {
+  option (id) = 5;
+  option (source) = SOURCE_BOTH;
+  option (no_delay) = true;
+
   // Do not close the connection before the acknowledgement arrives
 }
 
-// ID: 6
 message DisconnectResponse {
+  option (id) = 6;
+  option (source) = SOURCE_BOTH;
+  option (no_delay) = true;
+
   // Empty - Both parties are required to close the connection after this
   // message has been received.
 }
 
-// ID: 7
 message PingRequest {
+  option (id) = 7;
+  option (source) = SOURCE_BOTH;
   // Empty
 }
 
-// ID: 8
 message PingResponse {
+  option (id) = 8;
+  option (source) = SOURCE_BOTH;
   // Empty
 }
 
-// ID: 9
 message DeviceInfoRequest {
+  option (id) = 9;
+  option (source) = SOURCE_CLIENT;
   // Empty
 }
 
-// ID: 10
 message DeviceInfoResponse {
+  option (id) = 10;
+  option (source) = SOURCE_SERVER;
+
   bool uses_password = 1;
 
   // The name of the node, given by "App.set_name()"
@@ -101,7 +165,7 @@ message DeviceInfoResponse {
   string mac_address = 3;
 
   // A string describing the ESPHome version. For example "1.10.0"
-  string esphome_core_version = 4;
+  string esphome_version = 4;
 
   // A string describing the date of compilation, this is generated by the compiler
   // and therefore may not be in the same format all the time.
@@ -112,24 +176,35 @@ message DeviceInfoResponse {
   string model = 6;
 
   bool has_deep_sleep = 7;
+
+  // The esphome project details if set
+  string project_name = 8;
+  string project_version = 9;
 }
 
-// ID: 11
 message ListEntitiesRequest {
+  option (id) = 11;
+  option (source) = SOURCE_CLIENT;
   // Empty
 }
-// ID: 19
 message ListEntitiesDoneResponse {
+  option (id) = 19;
+  option (source) = SOURCE_SERVER;
+  option (no_delay) = true;
   // Empty
 }
-// ID: 20
 message SubscribeStatesRequest {
+  option (id) = 20;
+  option (source) = SOURCE_CLIENT;
   // Empty
 }
 
 // ==================== BINARY SENSOR ====================
-// ID: 12
 message ListEntitiesBinarySensorResponse {
+  option (id) = 12;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BINARY_SENSOR";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -138,15 +213,25 @@ message ListEntitiesBinarySensorResponse {
   string device_class = 5;
   bool is_status_binary_sensor = 6;
 }
-// ID: 21
 message BinarySensorStateResponse {
+  option (id) = 21;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_BINARY_SENSOR";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool state = 2;
+  // If the binary sensor does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
 }
 
 // ==================== COVER ====================
-// ID: 13
 message ListEntitiesCoverResponse {
+  option (id) = 13;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_COVER";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -157,38 +242,47 @@ message ListEntitiesCoverResponse {
   bool supports_tilt = 7;
   string device_class = 8;
 }
-// ID: 22
-message CoverStateResponse {
-  fixed32 key = 1;
 
+enum LegacyCoverState {
+  LEGACY_COVER_STATE_OPEN = 0;
+  LEGACY_COVER_STATE_CLOSED = 1;
+}
+enum CoverOperation {
+  COVER_OPERATION_IDLE = 0;
+  COVER_OPERATION_IS_OPENING = 1;
+  COVER_OPERATION_IS_CLOSING = 2;
+}
+message CoverStateResponse {
+  option (id) = 22;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_COVER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
   // legacy: state has been removed in 1.13
   // clients/servers must still send/accept it until the next protocol change
-  enum LegacyCoverState {
-    OPEN = 0;
-    CLOSED = 1;
-  }
   LegacyCoverState legacy_state = 2;
 
   float position = 3;
   float tilt = 4;
-  enum CoverOperation {
-    IDLE = 0;
-    IS_OPENING = 1;
-    IS_CLOSING = 2;
-  }
   CoverOperation current_operation = 5;
 }
-// ID: 30
+
+enum LegacyCoverCommand {
+  LEGACY_COVER_COMMAND_OPEN = 0;
+  LEGACY_COVER_COMMAND_CLOSE = 1;
+  LEGACY_COVER_COMMAND_STOP = 2;
+}
 message CoverCommandRequest {
+  option (id) = 30;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_COVER";
+  option (no_delay) = true;
+
   fixed32 key = 1;
 
   // legacy: command has been removed in 1.13
   // clients/servers must still send/accept it until the next protocol change
-  enum LegacyCoverCommand {
-    OPEN = 0;
-    CLOSE = 1;
-    STOP = 2;
-  }
   bool has_legacy_command = 2;
   LegacyCoverCommand legacy_command = 3;
 
@@ -200,8 +294,11 @@ message CoverCommandRequest {
 }
 
 // ==================== FAN ====================
-// ID: 14
 message ListEntitiesFanResponse {
+  option (id) = 14;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_FAN";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -209,33 +306,56 @@ message ListEntitiesFanResponse {
 
   bool supports_oscillation = 5;
   bool supports_speed = 6;
+  bool supports_direction = 7;
+  int32 supported_speed_count = 8;
 }
 enum FanSpeed {
-  LOW = 0;
-  MEDIUM = 1;
-  HIGH = 2;
+  FAN_SPEED_LOW = 0;
+  FAN_SPEED_MEDIUM = 1;
+  FAN_SPEED_HIGH = 2;
+}
+enum FanDirection {
+  FAN_DIRECTION_FORWARD = 0;
+  FAN_DIRECTION_REVERSE = 1;
 }
-// ID: 23
 message FanStateResponse {
+  option (id) = 23;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_FAN";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool state = 2;
   bool oscillating = 3;
-  FanSpeed speed = 4;
+  FanSpeed speed = 4 [deprecated = true];
+  FanDirection direction = 5;
+  int32 speed_level = 6;
 }
-// ID: 31
 message FanCommandRequest {
+  option (id) = 31;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_FAN";
+  option (no_delay) = true;
+
   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 ====================
-// ID: 15
 message ListEntitiesLightResponse {
+  option (id) = 15;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_LIGHT";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -249,8 +369,12 @@ message ListEntitiesLightResponse {
   float max_mireds = 10;
   repeated string effects = 11;
 }
-// ID: 24
 message LightStateResponse {
+  option (id) = 24;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_LIGHT";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool state = 2;
   float brightness = 3;
@@ -261,8 +385,12 @@ message LightStateResponse {
   float color_temperature = 8;
   string effect = 9;
 }
-// ID: 32
 message LightCommandRequest {
+  option (id) = 32;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_LIGHT";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool has_state = 2;
   bool state = 3;
@@ -285,8 +413,16 @@ message LightCommandRequest {
 }
 
 // ==================== SENSOR ====================
-// ID: 16
+enum SensorStateClass {
+  STATE_CLASS_NONE = 0;
+  STATE_CLASS_MEASUREMENT = 1;
+}
+
 message ListEntitiesSensorResponse {
+  option (id) = 16;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SENSOR";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -295,16 +431,29 @@ message ListEntitiesSensorResponse {
   string icon = 5;
   string unit_of_measurement = 6;
   int32 accuracy_decimals = 7;
+  bool force_update = 8;
+  string device_class = 9;
+  SensorStateClass state_class = 10;
 }
-// ID: 25
 message SensorStateResponse {
+  option (id) = 25;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SENSOR";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   float state = 2;
+  // If the sensor does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
 }
 
 // ==================== SWITCH ====================
-// ID: 17
 message ListEntitiesSwitchResponse {
+  option (id) = 17;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SWITCH";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -313,20 +462,31 @@ message ListEntitiesSwitchResponse {
   string icon = 5;
   bool assumed_state = 6;
 }
-// ID: 26
 message SwitchStateResponse {
+  option (id) = 26;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SWITCH";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool state = 2;
 }
-// ID: 33
 message SwitchCommandRequest {
+  option (id) = 33;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SWITCH";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool state = 2;
 }
 
 // ==================== TEXT SENSOR ====================
-// ID: 18
 message ListEntitiesTextSensorResponse {
+  option (id) = 18;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_TEXT_SENSOR";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -334,29 +494,41 @@ message ListEntitiesTextSensorResponse {
 
   string icon = 5;
 }
-// ID: 27
 message TextSensorStateResponse {
+  option (id) = 27;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_TEXT_SENSOR";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   string state = 2;
+  // If the text sensor does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
 }
 
 // ==================== SUBSCRIBE LOGS ====================
 enum LogLevel {
-  NONE = 0;
-  ERROR = 1;
-  WARN = 2;
-  INFO = 3;
-  DEBUG = 4;
-  VERBOSE = 5;
-  VERY_VERBOSE = 6;
+  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;
 }
-// ID: 28
 message SubscribeLogsRequest {
+  option (id) = 28;
+  option (source) = SOURCE_CLIENT;
   LogLevel level = 1;
   bool dump_config = 2;
 }
-// ID: 29
 message SubscribeLogsResponse {
+  option (id) = 29;
+  option (source) = SOURCE_SERVER;
+  option (log) = false;
+  option (no_delay) = false;
+
   LogLevel level = 1;
   string tag = 2;
   string message = 3;
@@ -364,109 +536,193 @@ message SubscribeLogsResponse {
 }
 
 // ==================== HOMEASSISTANT.SERVICE ====================
-// ID: 34
-message SubscribeServiceCallsRequest {
-
+message SubscribeHomeassistantServicesRequest {
+  option (id) = 34;
+  option (source) = SOURCE_CLIENT;
 }
 
-// ID: 35
-message ServiceCallResponse {
+message HomeassistantServiceMap {
+  string key = 1;
+  string value = 2;
+}
+
+message HomeassistantServiceResponse {
+  option (id) = 35;
+  option (source) = SOURCE_SERVER;
+  option (no_delay) = true;
+
   string service = 1;
-  map<string, string> data = 2;
-  map<string, string> data_template = 3;
-  map<string, string> variables = 4;
+  repeated HomeassistantServiceMap data = 2;
+  repeated HomeassistantServiceMap data_template = 3;
+  repeated HomeassistantServiceMap variables = 4;
+  bool is_event = 5;
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================
 // 1. Client sends SubscribeHomeAssistantStatesRequest
 // 2. Server responds with zero or more SubscribeHomeAssistantStateResponse (async)
 // 3. Client sends HomeAssistantStateResponse for state changes.
-// ID: 38
 message SubscribeHomeAssistantStatesRequest {
-
+  option (id) = 38;
+  option (source) = SOURCE_CLIENT;
 }
 
-// ID: 39
 message SubscribeHomeAssistantStateResponse {
+  option (id) = 39;
+  option (source) = SOURCE_SERVER;
   string entity_id = 1;
+  string attribute = 2;
 }
 
-// ID: 40
 message HomeAssistantStateResponse {
+  option (id) = 40;
+  option (source) = SOURCE_CLIENT;
+  option (no_delay) = true;
+
   string entity_id = 1;
   string state = 2;
+  string attribute = 3;
 }
 
 // ==================== IMPORT TIME ====================
-// ID: 36
 message GetTimeRequest {
-
+  option (id) = 36;
+  option (source) = SOURCE_BOTH;
 }
 
-// ID: 37
 message GetTimeResponse {
+  option (id) = 37;
+  option (source) = SOURCE_BOTH;
+  option (no_delay) = true;
+
   fixed32 epoch_seconds = 1;
 }
 
 // ==================== USER-DEFINES SERVICES ====================
+enum ServiceArgType {
+  SERVICE_ARG_TYPE_BOOL = 0;
+  SERVICE_ARG_TYPE_INT = 1;
+  SERVICE_ARG_TYPE_FLOAT = 2;
+  SERVICE_ARG_TYPE_STRING = 3;
+  SERVICE_ARG_TYPE_BOOL_ARRAY = 4;
+  SERVICE_ARG_TYPE_INT_ARRAY = 5;
+  SERVICE_ARG_TYPE_FLOAT_ARRAY = 6;
+  SERVICE_ARG_TYPE_STRING_ARRAY = 7;
+}
 message ListEntitiesServicesArgument {
   string name = 1;
-  enum Type {
-    BOOL = 0;
-    INT = 1;
-    FLOAT = 2;
-    STRING = 3;
-  }
-  Type type = 2;
+  ServiceArgType type = 2;
 }
-// ID: 41
 message ListEntitiesServicesResponse {
+  option (id) = 41;
+  option (source) = SOURCE_SERVER;
+
   string name = 1;
   fixed32 key = 2;
   repeated ListEntitiesServicesArgument args = 3;
 }
 message ExecuteServiceArgument {
   bool bool_ = 1;
-  int32 int_ = 2;
+  int32 legacy_int = 2;
   float float_ = 3;
   string string_ = 4;
+  // ESPHome 1.14 (api v1.3) make int a signed value
+  sint32 int_ = 5;
+  repeated bool bool_array = 6 [packed=false];
+  repeated sint32 int_array = 7 [packed=false];
+  repeated float float_array = 8 [packed=false];
+  repeated string string_array = 9;
 }
-// ID: 42
 message ExecuteServiceRequest {
+  option (id) = 42;
+  option (source) = SOURCE_CLIENT;
+  option (no_delay) = true;
+
   fixed32 key = 1;
   repeated ExecuteServiceArgument args = 2;
 }
 
 // ==================== CAMERA ====================
-// ID: 43
 message ListEntitiesCameraResponse {
+  option (id) = 43;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_ESP32_CAMERA";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
   string unique_id = 4;
 }
 
-// ID: 44
 message CameraImageResponse {
+  option (id) = 44;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_ESP32_CAMERA";
+
   fixed32 key = 1;
   bytes data = 2;
   bool done = 3;
 }
-// ID: 45
 message CameraImageRequest {
+  option (id) = 45;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_ESP32_CAMERA";
+  option (no_delay) = true;
+
   bool single = 1;
   bool stream = 2;
 }
 
 // ==================== CLIMATE ====================
 enum ClimateMode {
-  OFF = 0;
-  AUTO = 1;
-  COOL = 2;
-  HEAT = 3;
+  CLIMATE_MODE_OFF = 0;
+  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;
+  CLIMATE_FAN_OFF = 1;
+  CLIMATE_FAN_AUTO = 2;
+  CLIMATE_FAN_LOW = 3;
+  CLIMATE_FAN_MEDIUM = 4;
+  CLIMATE_FAN_HIGH = 5;
+  CLIMATE_FAN_MIDDLE = 6;
+  CLIMATE_FAN_FOCUS = 7;
+  CLIMATE_FAN_DIFFUSE = 8;
+}
+enum ClimateSwingMode {
+  CLIMATE_SWING_OFF = 0;
+  CLIMATE_SWING_BOTH = 1;
+  CLIMATE_SWING_VERTICAL = 2;
+  CLIMATE_SWING_HORIZONTAL = 3;
+}
+enum ClimateAction {
+  CLIMATE_ACTION_OFF = 0;
+  // values same as mode for readability
+  CLIMATE_ACTION_COOLING = 2;
+  CLIMATE_ACTION_HEATING = 3;
+  CLIMATE_ACTION_IDLE = 4;
+  CLIMATE_ACTION_DRYING = 5;
+  CLIMATE_ACTION_FAN = 6;
+}
+enum ClimatePreset {
+  CLIMATE_PRESET_ECO = 0;
+  CLIMATE_PRESET_AWAY = 1;
+  CLIMATE_PRESET_BOOST = 2;
+  CLIMATE_PRESET_COMFORT = 3;
+  CLIMATE_PRESET_HOME = 4;
+  CLIMATE_PRESET_SLEEP = 5;
+  CLIMATE_PRESET_ACTIVITY = 6;
 }
-// ID: 46
 message ListEntitiesClimateResponse {
+  option (id) = 46;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_CLIMATE";
+
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
@@ -479,9 +735,19 @@ message ListEntitiesClimateResponse {
   float visual_max_temperature = 9;
   float visual_temperature_step = 10;
   bool 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;
 }
-// ID: 47
 message ClimateStateResponse {
+  option (id) = 47;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_CLIMATE";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   ClimateMode mode = 2;
   float current_temperature = 3;
@@ -489,9 +755,19 @@ message ClimateStateResponse {
   float target_temperature_low = 5;
   float target_temperature_high = 6;
   bool 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;
 }
-// ID: 48
 message ClimateCommandRequest {
+  option (id) = 48;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_CLIMATE";
+  option (no_delay) = true;
+
   fixed32 key = 1;
   bool has_mode = 2;
   ClimateMode mode = 3;
@@ -503,4 +779,14 @@ message ClimateCommandRequest {
   float target_temperature_high = 9;
   bool has_away = 10;
   bool 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;
 }

esphome/components/api/api_connection.cpp

@@ -0,0 +1,747 @@
+#include "api_connection.h"
+#include "esphome/core/log.h"
+#include "esphome/core/util.h"
+#include "esphome/core/version.h"
+
+#ifdef USE_DEEP_SLEEP
+#include "esphome/components/deep_sleep/deep_sleep_component.h"
+#endif
+#ifdef USE_HOMEASSISTANT_TIME
+#include "esphome/components/homeassistant/time/homeassistant_time.h"
+#endif
+#ifdef USE_FAN
+#include "esphome/components/fan/fan_helpers.h"
+#endif
+
+namespace esphome {
+namespace api {
+
+static const char *TAG = "api.connection";
+
+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);
+
+  this->send_buffer_.reserve(64);
+  this->recv_buffer_.reserve(32);
+  this->client_info_ = this->client_->remoteIP().toString().c_str();
+  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)
+    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;
+}
+
+void APIConnection::loop() {
+  if (this->remove_)
+    return;
+
+  if (this->next_close_) {
+    this->disconnect_client();
+    return;
+  }
+
+  if (!network_is_connected()) {
+    // when network is disconnected force disconnect immediately
+    // don't wait for timeout
+    this->on_fatal_error();
+    return;
+  }
+  if (this->client_->disconnected()) {
+    // failsafe for disconnect logic
+    this->on_disconnect_();
+    return;
+  }
+  this->parse_recv_buffer_();
+
+  this->list_entities_iterator_.advance();
+  this->initial_state_iterator_.advance();
+
+  const uint32_t keepalive = 60000;
+  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();
+    }
+  } else if (millis() - this->last_traffic_ > keepalive) {
+    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 (success) {
+        this->image_reader_.consume_data(to_send);
+      }
+      if (success && done) {
+        this->image_reader_.return_image();
+      }
+    }
+  }
+#endif
+}
+
+std::string get_default_unique_id(const std::string &component_type, Nameable *nameable) {
+  return App.get_name() + component_type + nameable->get_object_id();
+}
+
+#ifdef USE_BINARY_SENSOR
+bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state) {
+  if (!this->state_subscription_)
+    return false;
+
+  BinarySensorStateResponse resp;
+  resp.key = binary_sensor->get_object_id_hash();
+  resp.state = state;
+  resp.missing_state = !binary_sensor->has_state();
+  return this->send_binary_sensor_state_response(resp);
+}
+bool APIConnection::send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor) {
+  ListEntitiesBinarySensorResponse msg;
+  msg.object_id = binary_sensor->get_object_id();
+  msg.key = binary_sensor->get_object_id_hash();
+  msg.name = binary_sensor->get_name();
+  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();
+  return this->send_list_entities_binary_sensor_response(msg);
+}
+#endif
+
+#ifdef USE_COVER
+bool APIConnection::send_cover_state(cover::Cover *cover) {
+  if (!this->state_subscription_)
+    return false;
+
+  auto traits = cover->get_traits();
+  CoverStateResponse resp{};
+  resp.key = cover->get_object_id_hash();
+  resp.legacy_state =
+      (cover->position == cover::COVER_OPEN) ? enums::LEGACY_COVER_STATE_OPEN : enums::LEGACY_COVER_STATE_CLOSED;
+  resp.position = cover->position;
+  if (traits.get_supports_tilt())
+    resp.tilt = cover->tilt;
+  resp.current_operation = static_cast<enums::CoverOperation>(cover->current_operation);
+  return this->send_cover_state_response(resp);
+}
+bool APIConnection::send_cover_info(cover::Cover *cover) {
+  auto traits = cover->get_traits();
+  ListEntitiesCoverResponse msg;
+  msg.key = cover->get_object_id_hash();
+  msg.object_id = cover->get_object_id();
+  msg.name = cover->get_name();
+  msg.unique_id = get_default_unique_id("cover", cover);
+  msg.assumed_state = traits.get_is_assumed_state();
+  msg.supports_position = traits.get_supports_position();
+  msg.supports_tilt = traits.get_supports_tilt();
+  msg.device_class = cover->get_device_class();
+  return this->send_list_entities_cover_response(msg);
+}
+void APIConnection::cover_command(const CoverCommandRequest &msg) {
+  cover::Cover *cover = App.get_cover_by_key(msg.key);
+  if (cover == nullptr)
+    return;
+
+  auto call = cover->make_call();
+  if (msg.has_legacy_command) {
+    switch (msg.legacy_command) {
+      case enums::LEGACY_COVER_COMMAND_OPEN:
+        call.set_command_open();
+        break;
+      case enums::LEGACY_COVER_COMMAND_CLOSE:
+        call.set_command_close();
+        break;
+      case enums::LEGACY_COVER_COMMAND_STOP:
+        call.set_command_stop();
+        break;
+    }
+  }
+  if (msg.has_position)
+    call.set_position(msg.position);
+  if (msg.has_tilt)
+    call.set_tilt(msg.tilt);
+  if (msg.stop)
+    call.set_command_stop();
+  call.perform();
+}
+#endif
+
+#ifdef USE_FAN
+bool APIConnection::send_fan_state(fan::FanState *fan) {
+  if (!this->state_subscription_)
+    return false;
+
+  auto traits = fan->get_traits();
+  FanStateResponse resp{};
+  resp.key = fan->get_object_id_hash();
+  resp.state = fan->state;
+  if (traits.supports_oscillation())
+    resp.oscillating = fan->oscillating;
+  if (traits.supports_speed()) {
+    resp.speed_level = fan->speed;
+    resp.speed = static_cast<enums::FanSpeed>(fan::speed_level_to_enum(fan->speed, traits.supported_speed_count()));
+  }
+  if (traits.supports_direction())
+    resp.direction = static_cast<enums::FanDirection>(fan->direction);
+  return this->send_fan_state_response(resp);
+}
+bool APIConnection::send_fan_info(fan::FanState *fan) {
+  auto traits = fan->get_traits();
+  ListEntitiesFanResponse msg;
+  msg.key = fan->get_object_id_hash();
+  msg.object_id = fan->get_object_id();
+  msg.name = fan->get_name();
+  msg.unique_id = get_default_unique_id("fan", 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();
+  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);
+  if (fan == nullptr)
+    return;
+
+  auto traits = fan->get_traits();
+
+  auto call = fan->make_call();
+  if (msg.has_state)
+    call.set_state(msg.state);
+  if (msg.has_oscillating)
+    call.set_oscillating(msg.oscillating);
+  if (msg.has_speed_level) {
+    // Prefer level
+    call.set_speed(msg.speed_level);
+  } else if (msg.has_speed) {
+    call.set_speed(fan::speed_enum_to_level(static_cast<fan::FanSpeed>(msg.speed), traits.supported_speed_count()));
+  }
+  if (msg.has_direction)
+    call.set_direction(static_cast<fan::FanDirection>(msg.direction));
+  call.perform();
+}
+#endif
+
+#ifdef USE_LIGHT
+bool APIConnection::send_light_state(light::LightState *light) {
+  if (!this->state_subscription_)
+    return false;
+
+  auto traits = light->get_traits();
+  auto values = light->remote_values;
+  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();
+  if (light->supports_effects())
+    resp.effect = light->get_effect_name();
+  return this->send_light_state_response(resp);
+}
+bool APIConnection::send_light_info(light::LightState *light) {
+  auto traits = light->get_traits();
+  ListEntitiesLightResponse msg;
+  msg.key = light->get_object_id_hash();
+  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.min_mireds = traits.get_min_mireds();
+    msg.max_mireds = traits.get_max_mireds();
+  }
+  if (light->supports_effects()) {
+    msg.effects.emplace_back("None");
+    for (auto *effect : light->get_effects())
+      msg.effects.push_back(effect->get_name());
+  }
+  return this->send_list_entities_light_response(msg);
+}
+void APIConnection::light_command(const LightCommandRequest &msg) {
+  light::LightState *light = App.get_light_by_key(msg.key);
+  if (light == nullptr)
+    return;
+
+  auto call = light->make_call();
+  if (msg.has_state)
+    call.set_state(msg.state);
+  if (msg.has_brightness)
+    call.set_brightness(msg.brightness);
+  if (msg.has_rgb) {
+    call.set_red(msg.red);
+    call.set_green(msg.green);
+    call.set_blue(msg.blue);
+  }
+  if (msg.has_white)
+    call.set_white(msg.white);
+  if (msg.has_color_temperature)
+    call.set_color_temperature(msg.color_temperature);
+  if (msg.has_transition_length)
+    call.set_transition_length(msg.transition_length);
+  if (msg.has_flash_length)
+    call.set_flash_length(msg.flash_length);
+  if (msg.has_effect)
+    call.set_effect(msg.effect);
+  call.perform();
+}
+#endif
+
+#ifdef USE_SENSOR
+bool APIConnection::send_sensor_state(sensor::Sensor *sensor, float state) {
+  if (!this->state_subscription_)
+    return false;
+
+  SensorStateResponse resp{};
+  resp.key = sensor->get_object_id_hash();
+  resp.state = state;
+  resp.missing_state = !sensor->has_state();
+  return this->send_sensor_state_response(resp);
+}
+bool APIConnection::send_sensor_info(sensor::Sensor *sensor) {
+  ListEntitiesSensorResponse msg;
+  msg.key = sensor->get_object_id_hash();
+  msg.object_id = sensor->get_object_id();
+  msg.name = sensor->get_name();
+  msg.unique_id = sensor->unique_id();
+  if (msg.unique_id.empty())
+    msg.unique_id = get_default_unique_id("sensor", sensor);
+  msg.icon = sensor->get_icon();
+  msg.unit_of_measurement = sensor->get_unit_of_measurement();
+  msg.accuracy_decimals = sensor->get_accuracy_decimals();
+  msg.force_update = sensor->get_force_update();
+  msg.device_class = sensor->get_device_class();
+  msg.state_class = static_cast<enums::SensorStateClass>(sensor->state_class);
+
+  return this->send_list_entities_sensor_response(msg);
+}
+#endif
+
+#ifdef USE_SWITCH
+bool APIConnection::send_switch_state(switch_::Switch *a_switch, bool state) {
+  if (!this->state_subscription_)
+    return false;
+
+  SwitchStateResponse resp{};
+  resp.key = a_switch->get_object_id_hash();
+  resp.state = state;
+  return this->send_switch_state_response(resp);
+}
+bool APIConnection::send_switch_info(switch_::Switch *a_switch) {
+  ListEntitiesSwitchResponse msg;
+  msg.key = a_switch->get_object_id_hash();
+  msg.object_id = a_switch->get_object_id();
+  msg.name = a_switch->get_name();
+  msg.unique_id = get_default_unique_id("switch", a_switch);
+  msg.icon = a_switch->get_icon();
+  msg.assumed_state = a_switch->assumed_state();
+  return this->send_list_entities_switch_response(msg);
+}
+void APIConnection::switch_command(const SwitchCommandRequest &msg) {
+  switch_::Switch *a_switch = App.get_switch_by_key(msg.key);
+  if (a_switch == nullptr)
+    return;
+
+  if (msg.state)
+    a_switch->turn_on();
+  else
+    a_switch->turn_off();
+}
+#endif
+
+#ifdef USE_TEXT_SENSOR
+bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state) {
+  if (!this->state_subscription_)
+    return false;
+
+  TextSensorStateResponse resp{};
+  resp.key = text_sensor->get_object_id_hash();
+  resp.state = std::move(state);
+  resp.missing_state = !text_sensor->has_state();
+  return this->send_text_sensor_state_response(resp);
+}
+bool APIConnection::send_text_sensor_info(text_sensor::TextSensor *text_sensor) {
+  ListEntitiesTextSensorResponse msg;
+  msg.key = text_sensor->get_object_id_hash();
+  msg.object_id = text_sensor->get_object_id();
+  msg.name = text_sensor->get_name();
+  msg.unique_id = text_sensor->unique_id();
+  if (msg.unique_id.empty())
+    msg.unique_id = get_default_unique_id("text_sensor", text_sensor);
+  msg.icon = text_sensor->get_icon();
+  return this->send_list_entities_text_sensor_response(msg);
+}
+#endif
+
+#ifdef USE_CLIMATE
+bool APIConnection::send_climate_state(climate::Climate *climate) {
+  if (!this->state_subscription_)
+    return false;
+
+  auto traits = climate->get_traits();
+  ClimateStateResponse resp{};
+  resp.key = climate->get_object_id_hash();
+  resp.mode = static_cast<enums::ClimateMode>(climate->mode);
+  resp.action = static_cast<enums::ClimateAction>(climate->action);
+  if (traits.get_supports_current_temperature())
+    resp.current_temperature = climate->current_temperature;
+  if (traits.get_supports_two_point_target_temperature()) {
+    resp.target_temperature_low = climate->target_temperature_low;
+    resp.target_temperature_high = climate->target_temperature_high;
+  } else {
+    resp.target_temperature = climate->target_temperature;
+  }
+  if (traits.get_supports_away())
+    resp.away = climate->away;
+  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());
+  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);
+}
+bool APIConnection::send_climate_info(climate::Climate *climate) {
+  auto traits = climate->get_traits();
+  ListEntitiesClimateResponse msg;
+  msg.key = climate->get_object_id_hash();
+  msg.object_id = climate->get_object_id();
+  msg.name = climate->get_name();
+  msg.unique_id = get_default_unique_id("climate", climate);
+  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, climate::CLIMATE_MODE_HEAT_COOL}) {
+    if (traits.supports_mode(mode))
+      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.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 const &custom_fan_mode : traits.get_supported_custom_fan_modes()) {
+    msg.supported_custom_fan_modes.push_back(custom_fan_mode);
+  }
+  for (auto preset : {climate::CLIMATE_PRESET_ECO, climate::CLIMATE_PRESET_AWAY, climate::CLIMATE_PRESET_BOOST,
+                      climate::CLIMATE_PRESET_COMFORT, climate::CLIMATE_PRESET_HOME, climate::CLIMATE_PRESET_SLEEP,
+                      climate::CLIMATE_PRESET_ACTIVITY}) {
+    if (traits.supports_preset(preset))
+      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 : {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));
+  }
+  return this->send_list_entities_climate_response(msg);
+}
+void APIConnection::climate_command(const ClimateCommandRequest &msg) {
+  climate::Climate *climate = App.get_climate_by_key(msg.key);
+  if (climate == nullptr)
+    return;
+
+  auto call = climate->make_call();
+  if (msg.has_mode)
+    call.set_mode(static_cast<climate::ClimateMode>(msg.mode));
+  if (msg.has_target_temperature)
+    call.set_target_temperature(msg.target_temperature);
+  if (msg.has_target_temperature_low)
+    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_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_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);
+}
+bool APIConnection::send_camera_info(esp32_camera::ESP32Camera *camera) {
+  ListEntitiesCameraResponse msg;
+  msg.key = camera->get_object_id_hash();
+  msg.object_id = camera->get_object_id();
+  msg.name = camera->get_name();
+  msg.unique_id = get_default_unique_id("camera", camera);
+  return this->send_list_entities_camera_response(msg);
+}
+void APIConnection::camera_image(const CameraImageRequest &msg) {
+  if (esp32_camera::global_esp32_camera == nullptr)
+    return;
+
+  if (msg.single)
+    esp32_camera::global_esp32_camera->request_image();
+  if (msg.stream)
+    esp32_camera::global_esp32_camera->request_stream();
+}
+#endif
+
+#ifdef USE_HOMEASSISTANT_TIME
+void APIConnection::on_get_time_response(const GetTimeResponse &value) {
+  if (homeassistant::global_homeassistant_time != nullptr)
+    homeassistant::global_homeassistant_time->set_epoch_time(value.epoch_seconds);
+}
+#endif
+
+bool APIConnection::send_log_message(int level, const char *tag, const char *line) {
+  if (this->log_subscription_ < level)
+    return false;
+
+  // Send raw so that we don't copy too much
+  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;
+  }
+}
+
+HelloResponse APIConnection::hello(const HelloRequest &msg) {
+  this->client_info_ = msg.client_info + " (" + this->client_->remoteIP().toString().c_str();
+  this->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 = 4;
+  resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
+  this->connection_state_ = ConnectionState::CONNECTED;
+  return resp;
+}
+ConnectResponse APIConnection::connect(const ConnectRequest &msg) {
+  bool correct = this->parent_->check_password(msg.password);
+
+  ConnectResponse resp;
+  // bool invalid_password = 1;
+  resp.invalid_password = !correct;
+  if (correct) {
+    ESP_LOGD(TAG, "Client '%s' connected successfully!", this->client_info_.c_str());
+    this->connection_state_ = ConnectionState::AUTHENTICATED;
+
+#ifdef USE_HOMEASSISTANT_TIME
+    if (homeassistant::global_homeassistant_time != nullptr) {
+      this->send_time_request();
+    }
+#endif
+  }
+  return resp;
+}
+DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
+  DeviceInfoResponse resp{};
+  resp.uses_password = this->parent_->uses_password();
+  resp.name = App.get_name();
+  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
+#ifdef USE_DEEP_SLEEP
+  resp.has_deep_sleep = deep_sleep::global_has_deep_sleep;
+#endif
+#ifdef ESPHOME_PROJECT_NAME
+  resp.project_name = ESPHOME_PROJECT_NAME;
+  resp.project_version = ESPHOME_PROJECT_VERSION;
+#endif
+  return resp;
+}
+void APIConnection::on_home_assistant_state_response(const HomeAssistantStateResponse &msg) {
+  for (auto &it : this->parent_->get_state_subs())
+    if (it.entity_id == msg.entity_id && it.attribute.value() == msg.attribute) {
+      it.callback(msg.state);
+    }
+}
+void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
+  bool found = false;
+  for (auto *service : this->parent_->get_user_services()) {
+    if (service->execute_service(msg)) {
+      found = true;
+    }
+  }
+  if (!found) {
+    ESP_LOGV(TAG, "Could not find matching service!");
+  }
+}
+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;
+    resp.attribute = it.attribute.value();
+    if (!this->send_subscribe_home_assistant_state_response(resp)) {
+      this->on_fatal_error();
+      return;
+    }
+  }
+}
+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()) {
+    delay(0);
+    if (needed_space > this->client_->space()) {
+      // SubscribeLogsResponse
+      if (message_type != 29) {
+        ESP_LOGV(TAG, "Cannot send message because of TCP buffer space");
+      }
+      delay(0);
+      return false;
+    }
+  }
+
+  this->client_->add(reinterpret_cast<char *>(header.data()), header.size(),
+                     ASYNC_WRITE_FLAG_COPY | ASYNC_WRITE_FLAG_MORE);
+  this->client_->add(reinterpret_cast<char *>(buffer.get_buffer()->data()), buffer.get_buffer()->size(),
+                     ASYNC_WRITE_FLAG_COPY);
+  bool ret = this->client_->send();
+  return ret;
+}
+void APIConnection::on_unauthenticated_access() {
+  ESP_LOGD(TAG, "'%s' tried to access without authentication.", this->client_info_.c_str());
+  this->on_fatal_error();
+}
+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();
+}
+void APIConnection::on_fatal_error() {
+  ESP_LOGV(TAG, "Error: Disconnecting %s", this->client_info_.c_str());
+  this->client_->close();
+  this->remove_ = true;
+}
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_connection.h

@@ -0,0 +1,172 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/application.h"
+#include "api_pb2.h"
+#include "api_pb2_service.h"
+#include "api_server.h"
+
+namespace esphome {
+namespace api {
+
+class APIConnection : public APIServerConnection {
+ public:
+  APIConnection(AsyncClient *client, APIServer *parent);
+  virtual ~APIConnection();
+
+  void disconnect_client();
+  void loop();
+
+  bool send_list_info_done() {
+    ListEntitiesDoneResponse resp;
+    return this->send_list_entities_done_response(resp);
+  }
+#ifdef USE_BINARY_SENSOR
+  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
+  bool send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
+#endif
+#ifdef USE_COVER
+  bool send_cover_state(cover::Cover *cover);
+  bool send_cover_info(cover::Cover *cover);
+  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);
+  void fan_command(const FanCommandRequest &msg) override;
+#endif
+#ifdef USE_LIGHT
+  bool send_light_state(light::LightState *light);
+  bool send_light_info(light::LightState *light);
+  void light_command(const LightCommandRequest &msg) override;
+#endif
+#ifdef USE_SENSOR
+  bool send_sensor_state(sensor::Sensor *sensor, float state);
+  bool send_sensor_info(sensor::Sensor *sensor);
+#endif
+#ifdef USE_SWITCH
+  bool send_switch_state(switch_::Switch *a_switch, bool state);
+  bool send_switch_info(switch_::Switch *a_switch);
+  void switch_command(const SwitchCommandRequest &msg) override;
+#endif
+#ifdef USE_TEXT_SENSOR
+  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state);
+  bool send_text_sensor_info(text_sensor::TextSensor *text_sensor);
+#endif
+#ifdef USE_ESP32_CAMERA
+  void send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
+  bool send_camera_info(esp32_camera::ESP32Camera *camera);
+  void camera_image(const CameraImageRequest &msg) override;
+#endif
+#ifdef USE_CLIMATE
+  bool send_climate_state(climate::Climate *climate);
+  bool send_climate_info(climate::Climate *climate);
+  void climate_command(const ClimateCommandRequest &msg) override;
+#endif
+  bool send_log_message(int level, const char *tag, const char *line);
+  void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
+    if (!this->service_call_subscription_)
+      return;
+    this->send_homeassistant_service_response(call);
+  }
+#ifdef USE_HOMEASSISTANT_TIME
+  void send_time_request() {
+    GetTimeRequest req;
+    this->send_get_time_request(req);
+  }
+#endif
+
+  void on_disconnect_response(const DisconnectResponse &value) override {
+    // we initiated disconnect_client
+    this->next_close_ = true;
+  }
+  void on_ping_response(const PingResponse &value) override {
+    // we initiated ping
+    this->sent_ping_ = false;
+  }
+  void on_home_assistant_state_response(const HomeAssistantStateResponse &msg) override;
+#ifdef USE_HOMEASSISTANT_TIME
+  void on_get_time_response(const GetTimeResponse &value) override;
+#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;
+  }
+  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(); }
+  void subscribe_states(const SubscribeStatesRequest &msg) override {
+    this->state_subscription_ = true;
+    this->initial_state_iterator_.begin();
+  }
+  void subscribe_logs(const SubscribeLogsRequest &msg) override {
+    this->log_subscription_ = msg.level;
+    if (msg.dump_config)
+      App.schedule_dump_config();
+  }
+  void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) override {
+    this->service_call_subscription_ = true;
+  }
+  void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) override;
+  GetTimeResponse get_time(const GetTimeRequest &msg) override {
+    // TODO
+    return {};
+  }
+  void execute_service(const ExecuteServiceRequest &msg) override;
+  bool is_authenticated() override { return this->connection_state_ == ConnectionState::AUTHENTICATED; }
+  bool is_connection_setup() override {
+    return this->connection_state_ == ConnectionState ::CONNECTED || this->is_authenticated();
+  }
+  void on_fatal_error() override;
+  void on_unauthenticated_access() override;
+  void on_no_setup_connection() override;
+  ProtoWriteBuffer create_buffer() override {
+    this->send_buffer_.clear();
+    return {&this->send_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_();
+
+  enum class ConnectionState {
+    WAITING_FOR_HELLO,
+    CONNECTED,
+    AUTHENTICATED,
+  } connection_state_{ConnectionState::WAITING_FOR_HELLO};
+
+  bool remove_{false};
+
+  std::vector<uint8_t> send_buffer_;
+  std::vector<uint8_t> recv_buffer_;
+
+  std::string client_info_;
+#ifdef USE_ESP32_CAMERA
+  esp32_camera::CameraImageReader image_reader_;
+#endif
+
+  bool state_subscription_{false};
+  int log_subscription_{ESPHOME_LOG_LEVEL_NONE};
+  uint32_t last_traffic_;
+  bool sent_ping_{false};
+  bool service_call_subscription_{false};
+  bool current_nodelay_{false};
+  bool next_close_{false};
+  AsyncClient *client_;
+  APIServer *parent_;
+  InitialStateIterator initial_state_iterator_;
+  ListEntitiesIterator list_entities_iterator_;
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_message.h

@@ -1,79 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "util.h"
-
-namespace esphome {
-namespace api {
-
-enum class APIMessageType {
-  HELLO_REQUEST = 1,
-  HELLO_RESPONSE = 2,
-  CONNECT_REQUEST = 3,
-  CONNECT_RESPONSE = 4,
-  DISCONNECT_REQUEST = 5,
-  DISCONNECT_RESPONSE = 6,
-  PING_REQUEST = 7,
-  PING_RESPONSE = 8,
-  DEVICE_INFO_REQUEST = 9,
-  DEVICE_INFO_RESPONSE = 10,
-
-  LIST_ENTITIES_REQUEST = 11,
-  LIST_ENTITIES_BINARY_SENSOR_RESPONSE = 12,
-  LIST_ENTITIES_COVER_RESPONSE = 13,
-  LIST_ENTITIES_FAN_RESPONSE = 14,
-  LIST_ENTITIES_LIGHT_RESPONSE = 15,
-  LIST_ENTITIES_SENSOR_RESPONSE = 16,
-  LIST_ENTITIES_SWITCH_RESPONSE = 17,
-  LIST_ENTITIES_TEXT_SENSOR_RESPONSE = 18,
-  LIST_ENTITIES_SERVICE_RESPONSE = 41,
-  LIST_ENTITIES_CAMERA_RESPONSE = 43,
-  LIST_ENTITIES_CLIMATE_RESPONSE = 46,
-  LIST_ENTITIES_DONE_RESPONSE = 19,
-
-  SUBSCRIBE_STATES_REQUEST = 20,
-  BINARY_SENSOR_STATE_RESPONSE = 21,
-  COVER_STATE_RESPONSE = 22,
-  FAN_STATE_RESPONSE = 23,
-  LIGHT_STATE_RESPONSE = 24,
-  SENSOR_STATE_RESPONSE = 25,
-  SWITCH_STATE_RESPONSE = 26,
-  TEXT_SENSOR_STATE_RESPONSE = 27,
-  CAMERA_IMAGE_RESPONSE = 44,
-  CLIMATE_STATE_RESPONSE = 47,
-
-  SUBSCRIBE_LOGS_REQUEST = 28,
-  SUBSCRIBE_LOGS_RESPONSE = 29,
-
-  COVER_COMMAND_REQUEST = 30,
-  FAN_COMMAND_REQUEST = 31,
-  LIGHT_COMMAND_REQUEST = 32,
-  SWITCH_COMMAND_REQUEST = 33,
-  CAMERA_IMAGE_REQUEST = 45,
-  CLIMATE_COMMAND_REQUEST = 48,
-
-  SUBSCRIBE_SERVICE_CALLS_REQUEST = 34,
-  SERVICE_CALL_RESPONSE = 35,
-  GET_TIME_REQUEST = 36,
-  GET_TIME_RESPONSE = 37,
-
-  SUBSCRIBE_HOME_ASSISTANT_STATES_REQUEST = 38,
-  SUBSCRIBE_HOME_ASSISTANT_STATE_RESPONSE = 39,
-  HOME_ASSISTANT_STATE_RESPONSE = 40,
-
-  EXECUTE_SERVICE_REQUEST = 42,
-};
-
-class APIMessage {
- public:
-  void decode(const uint8_t *buffer, size_t length);
-  virtual bool decode_varint(uint32_t field_id, uint32_t value);
-  virtual bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len);
-  virtual bool decode_32bit(uint32_t field_id, uint32_t value);
-  virtual APIMessageType message_type() const = 0;
-
-  virtual void encode(APIBuffer &buffer);
-};
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/api_options.proto

@@ -0,0 +1,24 @@
+syntax = "proto2";
+import "google/protobuf/descriptor.proto";
+
+
+enum APISourceType {
+    SOURCE_BOTH = 0;
+    SOURCE_SERVER = 1;
+    SOURCE_CLIENT = 2;
+}
+
+message void {}
+
+extend google.protobuf.MethodOptions {
+    optional bool needs_setup_connection = 1038 [default=true];
+    optional bool needs_authentication = 1039 [default=true];
+}
+
+extend google.protobuf.MessageOptions {
+    optional uint32 id = 1036 [default=0];
+    optional APISourceType source = 1037 [default=SOURCE_BOTH];
+    optional string ifdef = 1038;
+    optional bool log = 1039 [default=true];
+    optional bool no_delay = 1040 [default=false];
+}

esphome/components/api/api_pb2.h

@@ -0,0 +1,783 @@
+// This file was automatically generated with a tool.
+// See scripts/api_protobuf/api_protobuf.py
+#pragma once
+
+#include "proto.h"
+
+namespace esphome {
+namespace api {
+
+namespace enums {
+
+enum LegacyCoverState : uint32_t {
+  LEGACY_COVER_STATE_OPEN = 0,
+  LEGACY_COVER_STATE_CLOSED = 1,
+};
+enum CoverOperation : uint32_t {
+  COVER_OPERATION_IDLE = 0,
+  COVER_OPERATION_IS_OPENING = 1,
+  COVER_OPERATION_IS_CLOSING = 2,
+};
+enum LegacyCoverCommand : uint32_t {
+  LEGACY_COVER_COMMAND_OPEN = 0,
+  LEGACY_COVER_COMMAND_CLOSE = 1,
+  LEGACY_COVER_COMMAND_STOP = 2,
+};
+enum FanSpeed : uint32_t {
+  FAN_SPEED_LOW = 0,
+  FAN_SPEED_MEDIUM = 1,
+  FAN_SPEED_HIGH = 2,
+};
+enum FanDirection : uint32_t {
+  FAN_DIRECTION_FORWARD = 0,
+  FAN_DIRECTION_REVERSE = 1,
+};
+enum SensorStateClass : uint32_t {
+  STATE_CLASS_NONE = 0,
+  STATE_CLASS_MEASUREMENT = 1,
+};
+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,
+};
+enum ServiceArgType : uint32_t {
+  SERVICE_ARG_TYPE_BOOL = 0,
+  SERVICE_ARG_TYPE_INT = 1,
+  SERVICE_ARG_TYPE_FLOAT = 2,
+  SERVICE_ARG_TYPE_STRING = 3,
+  SERVICE_ARG_TYPE_BOOL_ARRAY = 4,
+  SERVICE_ARG_TYPE_INT_ARRAY = 5,
+  SERVICE_ARG_TYPE_FLOAT_ARRAY = 6,
+  SERVICE_ARG_TYPE_STRING_ARRAY = 7,
+};
+enum ClimateMode : uint32_t {
+  CLIMATE_MODE_OFF = 0,
+  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,
+  CLIMATE_FAN_OFF = 1,
+  CLIMATE_FAN_AUTO = 2,
+  CLIMATE_FAN_LOW = 3,
+  CLIMATE_FAN_MEDIUM = 4,
+  CLIMATE_FAN_HIGH = 5,
+  CLIMATE_FAN_MIDDLE = 6,
+  CLIMATE_FAN_FOCUS = 7,
+  CLIMATE_FAN_DIFFUSE = 8,
+};
+enum ClimateSwingMode : uint32_t {
+  CLIMATE_SWING_OFF = 0,
+  CLIMATE_SWING_BOTH = 1,
+  CLIMATE_SWING_VERTICAL = 2,
+  CLIMATE_SWING_HORIZONTAL = 3,
+};
+enum ClimateAction : uint32_t {
+  CLIMATE_ACTION_OFF = 0,
+  CLIMATE_ACTION_COOLING = 2,
+  CLIMATE_ACTION_HEATING = 3,
+  CLIMATE_ACTION_IDLE = 4,
+  CLIMATE_ACTION_DRYING = 5,
+  CLIMATE_ACTION_FAN = 6,
+};
+enum ClimatePreset : uint32_t {
+  CLIMATE_PRESET_ECO = 0,
+  CLIMATE_PRESET_AWAY = 1,
+  CLIMATE_PRESET_BOOST = 2,
+  CLIMATE_PRESET_COMFORT = 3,
+  CLIMATE_PRESET_HOME = 4,
+  CLIMATE_PRESET_SLEEP = 5,
+  CLIMATE_PRESET_ACTIVITY = 6,
+};
+
+}  // namespace enums
+
+class HelloRequest : public ProtoMessage {
+ public:
+  std::string client_info{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class HelloResponse : public ProtoMessage {
+ public:
+  uint32_t api_version_major{0};
+  uint32_t api_version_minor{0};
+  std::string server_info{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ConnectRequest : public ProtoMessage {
+ public:
+  std::string password{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class ConnectResponse : public ProtoMessage {
+ public:
+  bool invalid_password{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class DisconnectRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class DisconnectResponse : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class PingRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class PingResponse : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class DeviceInfoRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class DeviceInfoResponse : public ProtoMessage {
+ public:
+  bool uses_password{false};
+  std::string name{};
+  std::string mac_address{};
+  std::string esphome_version{};
+  std::string compilation_time{};
+  std::string model{};
+  bool has_deep_sleep{false};
+  std::string project_name{};
+  std::string project_version{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class ListEntitiesDoneResponse : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class SubscribeStatesRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class ListEntitiesBinarySensorResponse : public ProtoMessage {
+ public:
+  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};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 BinarySensorStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool state{false};
+  bool missing_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesCoverResponse : public ProtoMessage {
+ public:
+  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{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 CoverStateResponse : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class CoverCommandRequest : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesFanResponse : public ProtoMessage {
+ public:
+  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};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 FanStateResponse : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class FanCommandRequest : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesLightResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  bool supports_brightness{false};
+  bool supports_rgb{false};
+  bool supports_white_value{false};
+  bool supports_color_temperature{false};
+  float min_mireds{0.0f};
+  float max_mireds{0.0f};
+  std::vector<std::string> effects{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 LightStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool state{false};
+  float brightness{0.0f};
+  float red{0.0f};
+  float green{0.0f};
+  float blue{0.0f};
+  float white{0.0f};
+  float color_temperature{0.0f};
+  std::string effect{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 LightCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_state{false};
+  bool state{false};
+  bool has_brightness{false};
+  float 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_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;
+  void dump_to(std::string &out) const override;
+
+ 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 ListEntitiesSensorResponse : public ProtoMessage {
+ public:
+  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{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 SensorStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  float state{0.0f};
+  bool missing_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesSwitchResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool assumed_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 SwitchStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SwitchCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesTextSensorResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class TextSensorStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::string state{};
+  bool missing_state{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 SubscribeLogsRequest : public ProtoMessage {
+ public:
+  enums::LogLevel level{};
+  bool dump_config{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SubscribeLogsResponse : public ProtoMessage {
+ public:
+  enums::LogLevel level{};
+  std::string tag{};
+  std::string message{};
+  bool send_failed{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SubscribeHomeassistantServicesRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class HomeassistantServiceMap : public ProtoMessage {
+ public:
+  std::string key{};
+  std::string value{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class HomeassistantServiceResponse : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SubscribeHomeAssistantStatesRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class SubscribeHomeAssistantStateResponse : public ProtoMessage {
+ public:
+  std::string entity_id{};
+  std::string attribute{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class HomeAssistantStateResponse : public ProtoMessage {
+ public:
+  std::string entity_id{};
+  std::string state{};
+  std::string attribute{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class GetTimeRequest : public ProtoMessage {
+ public:
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+};
+class GetTimeResponse : public ProtoMessage {
+ public:
+  uint32_t epoch_seconds{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+};
+class ListEntitiesServicesArgument : public ProtoMessage {
+ public:
+  std::string name{};
+  enums::ServiceArgType type{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesServicesResponse : public ProtoMessage {
+ public:
+  std::string name{};
+  uint32_t key{0};
+  std::vector<ListEntitiesServicesArgument> args{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class ExecuteServiceArgument : public ProtoMessage {
+ public:
+  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;
+  void dump_to(std::string &out) const override;
+
+ 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 ExecuteServiceRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::vector<ExecuteServiceArgument> args{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class ListEntitiesCameraResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class CameraImageResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::string data{};
+  bool done{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 CameraImageRequest : public ProtoMessage {
+ public:
+  bool single{false};
+  bool stream{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ListEntitiesClimateResponse : public ProtoMessage {
+ public:
+  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 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{};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void dump_to(std::string &out) const override;
+
+ 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 ClimateStateResponse : public ProtoMessage {
+ public:
+  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 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;
+  void dump_to(std::string &out) const override;
+
+ 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_away{false};
+  bool 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;
+  void dump_to(std::string &out) const override;
+
+ 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;
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -0,0 +1,552 @@
+// This file was automatically generated with a tool.
+// See scripts/api_protobuf/api_protobuf.py
+#include "api_pb2_service.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace api {
+
+static const char *TAG = "api.service";
+
+bool APIServerConnectionBase::send_hello_response(const HelloResponse &msg) {
+  ESP_LOGVV(TAG, "send_hello_response: %s", msg.dump().c_str());
+  return this->send_message_<HelloResponse>(msg, 2);
+}
+bool APIServerConnectionBase::send_connect_response(const ConnectResponse &msg) {
+  ESP_LOGVV(TAG, "send_connect_response: %s", msg.dump().c_str());
+  return this->send_message_<ConnectResponse>(msg, 4);
+}
+bool APIServerConnectionBase::send_disconnect_request(const DisconnectRequest &msg) {
+  ESP_LOGVV(TAG, "send_disconnect_request: %s", msg.dump().c_str());
+  return this->send_message_<DisconnectRequest>(msg, 5);
+}
+bool APIServerConnectionBase::send_disconnect_response(const DisconnectResponse &msg) {
+  ESP_LOGVV(TAG, "send_disconnect_response: %s", msg.dump().c_str());
+  return this->send_message_<DisconnectResponse>(msg, 6);
+}
+bool APIServerConnectionBase::send_ping_request(const PingRequest &msg) {
+  ESP_LOGVV(TAG, "send_ping_request: %s", msg.dump().c_str());
+  return this->send_message_<PingRequest>(msg, 7);
+}
+bool APIServerConnectionBase::send_ping_response(const PingResponse &msg) {
+  ESP_LOGVV(TAG, "send_ping_response: %s", msg.dump().c_str());
+  return this->send_message_<PingResponse>(msg, 8);
+}
+bool APIServerConnectionBase::send_device_info_response(const DeviceInfoResponse &msg) {
+  ESP_LOGVV(TAG, "send_device_info_response: %s", msg.dump().c_str());
+  return this->send_message_<DeviceInfoResponse>(msg, 10);
+}
+bool APIServerConnectionBase::send_list_entities_done_response(const ListEntitiesDoneResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_done_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesDoneResponse>(msg, 19);
+}
+#ifdef USE_BINARY_SENSOR
+bool APIServerConnectionBase::send_list_entities_binary_sensor_response(const ListEntitiesBinarySensorResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_binary_sensor_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesBinarySensorResponse>(msg, 12);
+}
+#endif
+#ifdef USE_BINARY_SENSOR
+bool APIServerConnectionBase::send_binary_sensor_state_response(const BinarySensorStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_binary_sensor_state_response: %s", msg.dump().c_str());
+  return this->send_message_<BinarySensorStateResponse>(msg, 21);
+}
+#endif
+#ifdef USE_COVER
+bool APIServerConnectionBase::send_list_entities_cover_response(const ListEntitiesCoverResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_cover_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesCoverResponse>(msg, 13);
+}
+#endif
+#ifdef USE_COVER
+bool APIServerConnectionBase::send_cover_state_response(const CoverStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_cover_state_response: %s", msg.dump().c_str());
+  return this->send_message_<CoverStateResponse>(msg, 22);
+}
+#endif
+#ifdef USE_COVER
+#endif
+#ifdef USE_FAN
+bool APIServerConnectionBase::send_list_entities_fan_response(const ListEntitiesFanResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_fan_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesFanResponse>(msg, 14);
+}
+#endif
+#ifdef USE_FAN
+bool APIServerConnectionBase::send_fan_state_response(const FanStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_fan_state_response: %s", msg.dump().c_str());
+  return this->send_message_<FanStateResponse>(msg, 23);
+}
+#endif
+#ifdef USE_FAN
+#endif
+#ifdef USE_LIGHT
+bool APIServerConnectionBase::send_list_entities_light_response(const ListEntitiesLightResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_light_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesLightResponse>(msg, 15);
+}
+#endif
+#ifdef USE_LIGHT
+bool APIServerConnectionBase::send_light_state_response(const LightStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_light_state_response: %s", msg.dump().c_str());
+  return this->send_message_<LightStateResponse>(msg, 24);
+}
+#endif
+#ifdef USE_LIGHT
+#endif
+#ifdef USE_SENSOR
+bool APIServerConnectionBase::send_list_entities_sensor_response(const ListEntitiesSensorResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_sensor_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesSensorResponse>(msg, 16);
+}
+#endif
+#ifdef USE_SENSOR
+bool APIServerConnectionBase::send_sensor_state_response(const SensorStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_sensor_state_response: %s", msg.dump().c_str());
+  return this->send_message_<SensorStateResponse>(msg, 25);
+}
+#endif
+#ifdef USE_SWITCH
+bool APIServerConnectionBase::send_list_entities_switch_response(const ListEntitiesSwitchResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_switch_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesSwitchResponse>(msg, 17);
+}
+#endif
+#ifdef USE_SWITCH
+bool APIServerConnectionBase::send_switch_state_response(const SwitchStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_switch_state_response: %s", msg.dump().c_str());
+  return this->send_message_<SwitchStateResponse>(msg, 26);
+}
+#endif
+#ifdef USE_SWITCH
+#endif
+#ifdef USE_TEXT_SENSOR
+bool APIServerConnectionBase::send_list_entities_text_sensor_response(const ListEntitiesTextSensorResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_text_sensor_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesTextSensorResponse>(msg, 18);
+}
+#endif
+#ifdef USE_TEXT_SENSOR
+bool APIServerConnectionBase::send_text_sensor_state_response(const TextSensorStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_text_sensor_state_response: %s", msg.dump().c_str());
+  return this->send_message_<TextSensorStateResponse>(msg, 27);
+}
+#endif
+bool APIServerConnectionBase::send_subscribe_logs_response(const SubscribeLogsResponse &msg) {
+  return this->send_message_<SubscribeLogsResponse>(msg, 29);
+}
+bool APIServerConnectionBase::send_homeassistant_service_response(const HomeassistantServiceResponse &msg) {
+  ESP_LOGVV(TAG, "send_homeassistant_service_response: %s", msg.dump().c_str());
+  return this->send_message_<HomeassistantServiceResponse>(msg, 35);
+}
+bool APIServerConnectionBase::send_subscribe_home_assistant_state_response(
+    const SubscribeHomeAssistantStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_subscribe_home_assistant_state_response: %s", msg.dump().c_str());
+  return this->send_message_<SubscribeHomeAssistantStateResponse>(msg, 39);
+}
+bool APIServerConnectionBase::send_get_time_request(const GetTimeRequest &msg) {
+  ESP_LOGVV(TAG, "send_get_time_request: %s", msg.dump().c_str());
+  return this->send_message_<GetTimeRequest>(msg, 36);
+}
+bool APIServerConnectionBase::send_get_time_response(const GetTimeResponse &msg) {
+  ESP_LOGVV(TAG, "send_get_time_response: %s", msg.dump().c_str());
+  return this->send_message_<GetTimeResponse>(msg, 37);
+}
+bool APIServerConnectionBase::send_list_entities_services_response(const ListEntitiesServicesResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_services_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesServicesResponse>(msg, 41);
+}
+#ifdef USE_ESP32_CAMERA
+bool APIServerConnectionBase::send_list_entities_camera_response(const ListEntitiesCameraResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_camera_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesCameraResponse>(msg, 43);
+}
+#endif
+#ifdef USE_ESP32_CAMERA
+bool APIServerConnectionBase::send_camera_image_response(const CameraImageResponse &msg) {
+  ESP_LOGVV(TAG, "send_camera_image_response: %s", msg.dump().c_str());
+  return this->send_message_<CameraImageResponse>(msg, 44);
+}
+#endif
+#ifdef USE_ESP32_CAMERA
+#endif
+#ifdef USE_CLIMATE
+bool APIServerConnectionBase::send_list_entities_climate_response(const ListEntitiesClimateResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_climate_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesClimateResponse>(msg, 46);
+}
+#endif
+#ifdef USE_CLIMATE
+bool APIServerConnectionBase::send_climate_state_response(const ClimateStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_climate_state_response: %s", msg.dump().c_str());
+  return this->send_message_<ClimateStateResponse>(msg, 47);
+}
+#endif
+#ifdef USE_CLIMATE
+#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);
+      ESP_LOGVV(TAG, "on_hello_request: %s", msg.dump().c_str());
+      this->on_hello_request(msg);
+      break;
+    }
+    case 3: {
+      ConnectRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_connect_request: %s", msg.dump().c_str());
+      this->on_connect_request(msg);
+      break;
+    }
+    case 5: {
+      DisconnectRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_disconnect_request: %s", msg.dump().c_str());
+      this->on_disconnect_request(msg);
+      break;
+    }
+    case 6: {
+      DisconnectResponse msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_disconnect_response: %s", msg.dump().c_str());
+      this->on_disconnect_response(msg);
+      break;
+    }
+    case 7: {
+      PingRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_ping_request: %s", msg.dump().c_str());
+      this->on_ping_request(msg);
+      break;
+    }
+    case 8: {
+      PingResponse msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_ping_response: %s", msg.dump().c_str());
+      this->on_ping_response(msg);
+      break;
+    }
+    case 9: {
+      DeviceInfoRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_device_info_request: %s", msg.dump().c_str());
+      this->on_device_info_request(msg);
+      break;
+    }
+    case 11: {
+      ListEntitiesRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_list_entities_request: %s", msg.dump().c_str());
+      this->on_list_entities_request(msg);
+      break;
+    }
+    case 20: {
+      SubscribeStatesRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_subscribe_states_request: %s", msg.dump().c_str());
+      this->on_subscribe_states_request(msg);
+      break;
+    }
+    case 28: {
+      SubscribeLogsRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_subscribe_logs_request: %s", msg.dump().c_str());
+      this->on_subscribe_logs_request(msg);
+      break;
+    }
+    case 30: {
+#ifdef USE_COVER
+      CoverCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_cover_command_request: %s", msg.dump().c_str());
+      this->on_cover_command_request(msg);
+#endif
+      break;
+    }
+    case 31: {
+#ifdef USE_FAN
+      FanCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_fan_command_request: %s", msg.dump().c_str());
+      this->on_fan_command_request(msg);
+#endif
+      break;
+    }
+    case 32: {
+#ifdef USE_LIGHT
+      LightCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_light_command_request: %s", msg.dump().c_str());
+      this->on_light_command_request(msg);
+#endif
+      break;
+    }
+    case 33: {
+#ifdef USE_SWITCH
+      SwitchCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_switch_command_request: %s", msg.dump().c_str());
+      this->on_switch_command_request(msg);
+#endif
+      break;
+    }
+    case 34: {
+      SubscribeHomeassistantServicesRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_subscribe_homeassistant_services_request: %s", msg.dump().c_str());
+      this->on_subscribe_homeassistant_services_request(msg);
+      break;
+    }
+    case 36: {
+      GetTimeRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_get_time_request: %s", msg.dump().c_str());
+      this->on_get_time_request(msg);
+      break;
+    }
+    case 37: {
+      GetTimeResponse msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_get_time_response: %s", msg.dump().c_str());
+      this->on_get_time_response(msg);
+      break;
+    }
+    case 38: {
+      SubscribeHomeAssistantStatesRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_subscribe_home_assistant_states_request: %s", msg.dump().c_str());
+      this->on_subscribe_home_assistant_states_request(msg);
+      break;
+    }
+    case 40: {
+      HomeAssistantStateResponse msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_home_assistant_state_response: %s", msg.dump().c_str());
+      this->on_home_assistant_state_response(msg);
+      break;
+    }
+    case 42: {
+      ExecuteServiceRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_execute_service_request: %s", msg.dump().c_str());
+      this->on_execute_service_request(msg);
+      break;
+    }
+    case 45: {
+#ifdef USE_ESP32_CAMERA
+      CameraImageRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_camera_image_request: %s", msg.dump().c_str());
+      this->on_camera_image_request(msg);
+#endif
+      break;
+    }
+    case 48: {
+#ifdef USE_CLIMATE
+      ClimateCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_climate_command_request: %s", msg.dump().c_str());
+      this->on_climate_command_request(msg);
+#endif
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+void APIServerConnection::on_hello_request(const HelloRequest &msg) {
+  HelloResponse ret = this->hello(msg);
+  if (!this->send_hello_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_connect_request(const ConnectRequest &msg) {
+  ConnectResponse ret = this->connect(msg);
+  if (!this->send_connect_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_disconnect_request(const DisconnectRequest &msg) {
+  DisconnectResponse ret = this->disconnect(msg);
+  if (!this->send_disconnect_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_ping_request(const PingRequest &msg) {
+  PingResponse ret = this->ping(msg);
+  if (!this->send_ping_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_device_info_request(const DeviceInfoRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  DeviceInfoResponse ret = this->device_info(msg);
+  if (!this->send_device_info_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_list_entities_request(const ListEntitiesRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->list_entities(msg);
+}
+void APIServerConnection::on_subscribe_states_request(const SubscribeStatesRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->subscribe_states(msg);
+}
+void APIServerConnection::on_subscribe_logs_request(const SubscribeLogsRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->subscribe_logs(msg);
+}
+void APIServerConnection::on_subscribe_homeassistant_services_request(
+    const SubscribeHomeassistantServicesRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->subscribe_homeassistant_services(msg);
+}
+void APIServerConnection::on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->subscribe_home_assistant_states(msg);
+}
+void APIServerConnection::on_get_time_request(const GetTimeRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  GetTimeResponse ret = this->get_time(msg);
+  if (!this->send_get_time_response(ret)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_execute_service_request(const ExecuteServiceRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->execute_service(msg);
+}
+#ifdef USE_COVER
+void APIServerConnection::on_cover_command_request(const CoverCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->cover_command(msg);
+}
+#endif
+#ifdef USE_FAN
+void APIServerConnection::on_fan_command_request(const FanCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->fan_command(msg);
+}
+#endif
+#ifdef USE_LIGHT
+void APIServerConnection::on_light_command_request(const LightCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->light_command(msg);
+}
+#endif
+#ifdef USE_SWITCH
+void APIServerConnection::on_switch_command_request(const SwitchCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->switch_command(msg);
+}
+#endif
+#ifdef USE_ESP32_CAMERA
+void APIServerConnection::on_camera_image_request(const CameraImageRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->camera_image(msg);
+}
+#endif
+#ifdef USE_CLIMATE
+void APIServerConnection::on_climate_command_request(const ClimateCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->climate_command(msg);
+}
+#endif
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -0,0 +1,185 @@
+// This file was automatically generated with a tool.
+// See scripts/api_protobuf/api_protobuf.py
+#pragma once
+
+#include "api_pb2.h"
+#include "esphome/core/defines.h"
+
+namespace esphome {
+namespace api {
+
+class APIServerConnectionBase : public ProtoService {
+ public:
+  virtual void on_hello_request(const HelloRequest &value){};
+  bool send_hello_response(const HelloResponse &msg);
+  virtual void on_connect_request(const ConnectRequest &value){};
+  bool send_connect_response(const ConnectResponse &msg);
+  bool send_disconnect_request(const DisconnectRequest &msg);
+  virtual void on_disconnect_request(const DisconnectRequest &value){};
+  bool send_disconnect_response(const DisconnectResponse &msg);
+  virtual void on_disconnect_response(const DisconnectResponse &value){};
+  bool send_ping_request(const PingRequest &msg);
+  virtual void on_ping_request(const PingRequest &value){};
+  bool send_ping_response(const PingResponse &msg);
+  virtual void on_ping_response(const PingResponse &value){};
+  virtual void on_device_info_request(const DeviceInfoRequest &value){};
+  bool send_device_info_response(const DeviceInfoResponse &msg);
+  virtual void on_list_entities_request(const ListEntitiesRequest &value){};
+  bool send_list_entities_done_response(const ListEntitiesDoneResponse &msg);
+  virtual void on_subscribe_states_request(const SubscribeStatesRequest &value){};
+#ifdef USE_BINARY_SENSOR
+  bool send_list_entities_binary_sensor_response(const ListEntitiesBinarySensorResponse &msg);
+#endif
+#ifdef USE_BINARY_SENSOR
+  bool send_binary_sensor_state_response(const BinarySensorStateResponse &msg);
+#endif
+#ifdef USE_COVER
+  bool send_list_entities_cover_response(const ListEntitiesCoverResponse &msg);
+#endif
+#ifdef USE_COVER
+  bool send_cover_state_response(const CoverStateResponse &msg);
+#endif
+#ifdef USE_COVER
+  virtual void on_cover_command_request(const CoverCommandRequest &value){};
+#endif
+#ifdef USE_FAN
+  bool send_list_entities_fan_response(const ListEntitiesFanResponse &msg);
+#endif
+#ifdef USE_FAN
+  bool send_fan_state_response(const FanStateResponse &msg);
+#endif
+#ifdef USE_FAN
+  virtual void on_fan_command_request(const FanCommandRequest &value){};
+#endif
+#ifdef USE_LIGHT
+  bool send_list_entities_light_response(const ListEntitiesLightResponse &msg);
+#endif
+#ifdef USE_LIGHT
+  bool send_light_state_response(const LightStateResponse &msg);
+#endif
+#ifdef USE_LIGHT
+  virtual void on_light_command_request(const LightCommandRequest &value){};
+#endif
+#ifdef USE_SENSOR
+  bool send_list_entities_sensor_response(const ListEntitiesSensorResponse &msg);
+#endif
+#ifdef USE_SENSOR
+  bool send_sensor_state_response(const SensorStateResponse &msg);
+#endif
+#ifdef USE_SWITCH
+  bool send_list_entities_switch_response(const ListEntitiesSwitchResponse &msg);
+#endif
+#ifdef USE_SWITCH
+  bool send_switch_state_response(const SwitchStateResponse &msg);
+#endif
+#ifdef USE_SWITCH
+  virtual void on_switch_command_request(const SwitchCommandRequest &value){};
+#endif
+#ifdef USE_TEXT_SENSOR
+  bool send_list_entities_text_sensor_response(const ListEntitiesTextSensorResponse &msg);
+#endif
+#ifdef USE_TEXT_SENSOR
+  bool send_text_sensor_state_response(const TextSensorStateResponse &msg);
+#endif
+  virtual void on_subscribe_logs_request(const SubscribeLogsRequest &value){};
+  bool send_subscribe_logs_response(const SubscribeLogsResponse &msg);
+  virtual void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &value){};
+  bool send_homeassistant_service_response(const HomeassistantServiceResponse &msg);
+  virtual void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &value){};
+  bool send_subscribe_home_assistant_state_response(const SubscribeHomeAssistantStateResponse &msg);
+  virtual void on_home_assistant_state_response(const HomeAssistantStateResponse &value){};
+  bool send_get_time_request(const GetTimeRequest &msg);
+  virtual void on_get_time_request(const GetTimeRequest &value){};
+  bool send_get_time_response(const GetTimeResponse &msg);
+  virtual void on_get_time_response(const GetTimeResponse &value){};
+  bool send_list_entities_services_response(const ListEntitiesServicesResponse &msg);
+  virtual void on_execute_service_request(const ExecuteServiceRequest &value){};
+#ifdef USE_ESP32_CAMERA
+  bool send_list_entities_camera_response(const ListEntitiesCameraResponse &msg);
+#endif
+#ifdef USE_ESP32_CAMERA
+  bool send_camera_image_response(const CameraImageResponse &msg);
+#endif
+#ifdef USE_ESP32_CAMERA
+  virtual void on_camera_image_request(const CameraImageRequest &value){};
+#endif
+#ifdef USE_CLIMATE
+  bool send_list_entities_climate_response(const ListEntitiesClimateResponse &msg);
+#endif
+#ifdef USE_CLIMATE
+  bool send_climate_state_response(const ClimateStateResponse &msg);
+#endif
+#ifdef USE_CLIMATE
+  virtual void on_climate_command_request(const ClimateCommandRequest &value){};
+#endif
+ protected:
+  bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
+};
+
+class APIServerConnection : public APIServerConnectionBase {
+ public:
+  virtual HelloResponse hello(const HelloRequest &msg) = 0;
+  virtual ConnectResponse connect(const ConnectRequest &msg) = 0;
+  virtual DisconnectResponse disconnect(const DisconnectRequest &msg) = 0;
+  virtual PingResponse ping(const PingRequest &msg) = 0;
+  virtual DeviceInfoResponse device_info(const DeviceInfoRequest &msg) = 0;
+  virtual void list_entities(const ListEntitiesRequest &msg) = 0;
+  virtual void subscribe_states(const SubscribeStatesRequest &msg) = 0;
+  virtual void subscribe_logs(const SubscribeLogsRequest &msg) = 0;
+  virtual void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) = 0;
+  virtual void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) = 0;
+  virtual GetTimeResponse get_time(const GetTimeRequest &msg) = 0;
+  virtual void execute_service(const ExecuteServiceRequest &msg) = 0;
+#ifdef USE_COVER
+  virtual void cover_command(const CoverCommandRequest &msg) = 0;
+#endif
+#ifdef USE_FAN
+  virtual void fan_command(const FanCommandRequest &msg) = 0;
+#endif
+#ifdef USE_LIGHT
+  virtual void light_command(const LightCommandRequest &msg) = 0;
+#endif
+#ifdef USE_SWITCH
+  virtual void switch_command(const SwitchCommandRequest &msg) = 0;
+#endif
+#ifdef USE_ESP32_CAMERA
+  virtual void camera_image(const CameraImageRequest &msg) = 0;
+#endif
+#ifdef USE_CLIMATE
+  virtual void climate_command(const ClimateCommandRequest &msg) = 0;
+#endif
+ protected:
+  void on_hello_request(const HelloRequest &msg) override;
+  void on_connect_request(const ConnectRequest &msg) override;
+  void on_disconnect_request(const DisconnectRequest &msg) override;
+  void on_ping_request(const PingRequest &msg) override;
+  void on_device_info_request(const DeviceInfoRequest &msg) override;
+  void on_list_entities_request(const ListEntitiesRequest &msg) override;
+  void on_subscribe_states_request(const SubscribeStatesRequest &msg) override;
+  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) override;
+  void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &msg) override;
+  void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) override;
+  void on_get_time_request(const GetTimeRequest &msg) override;
+  void on_execute_service_request(const ExecuteServiceRequest &msg) override;
+#ifdef USE_COVER
+  void on_cover_command_request(const CoverCommandRequest &msg) override;
+#endif
+#ifdef USE_FAN
+  void on_fan_command_request(const FanCommandRequest &msg) override;
+#endif
+#ifdef USE_LIGHT
+  void on_light_command_request(const LightCommandRequest &msg) override;
+#endif
+#ifdef USE_SWITCH
+  void on_switch_command_request(const SwitchCommandRequest &msg) override;
+#endif
+#ifdef USE_ESP32_CAMERA
+  void on_camera_image_request(const CameraImageRequest &msg) override;
+#endif
+#ifdef USE_CLIMATE
+  void on_climate_command_request(const ClimateCommandRequest &msg) override;
+#endif
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/api_server.cpp

@@ -1,18 +1,11 @@
-#include <utility>
-
 #include "api_server.h"
-#include "basic_messages.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/version.h"
 
-#ifdef USE_DEEP_SLEEP
-#include "esphome/components/deep_sleep/deep_sleep_component.h"
-#endif
-#ifdef USE_HOMEASSISTANT_TIME
-#include "esphome/components/homeassistant/time/homeassistant_time.h"
-#endif
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
 #endif
@@ -209,15 +202,17 @@ void APIServer::set_port(uint16_t port) { this->port_ = port; }
 APIServer *global_api_server = nullptr;
 
 void APIServer::set_password(const std::string &password) { this->password_ = password; }
-void APIServer::send_service_call(ServiceCallResponse &call) {
+void APIServer::send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
   for (auto *client : this->clients_) {
-    client->send_service_call(call);
+    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),
   });
 }
@@ -237,965 +232,10 @@ void APIServer::request_time() {
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
 void APIServer::on_shutdown() {
   for (auto *c : this->clients_) {
-    c->send_disconnect_request();
+    c->send_disconnect_request(DisconnectRequest());
   }
   delay(10);
 }
 
-// APIConnection
-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);
-
-  this->send_buffer_.reserve(64);
-  this->recv_buffer_.reserve(32);
-  this->client_info_ = this->client_->remoteIP().toString().c_str();
-  this->last_traffic_ = millis();
-}
-APIConnection::~APIConnection() { delete this->client_; }
-void APIConnection::on_error_(int8_t error) {
-  // disconnect will also be called, nothing to do here
-  this->remove_ = true;
-}
-void APIConnection::on_disconnect_() {
-  // delete self, generally unsafe but not in this case.
-  this->remove_ = true;
-}
-void APIConnection::on_timeout_(uint32_t time) { this->disconnect_client(); }
-void APIConnection::on_data_(uint8_t *buf, size_t len) {
-  if (len == 0 || buf == nullptr)
-    return;
-
-  this->recv_buffer_.insert(this->recv_buffer_.end(), buf, buf + len);
-  // TODO: On ESP32, use queue to notify main thread of new data
-}
-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->fatal_error_();
-      return;
-    }
-    uint32_t i = 1;
-    const uint32_t size = this->recv_buffer_.size();
-    uint32_t msg_size = 0;
-    while (i < size) {
-      const uint8_t dat = this->recv_buffer_[i];
-      msg_size |= (dat & 0x7F);
-      // consume
-      i += 1;
-      if ((dat & 0x80) == 0x00) {
-        break;
-      } else {
-        msg_size <<= 7;
-      }
-    }
-    if (i == size)
-      // not enough data there yet
-      return;
-
-    uint32_t msg_type = 0;
-    bool msg_type_done = false;
-    while (i < size) {
-      const uint8_t dat = this->recv_buffer_[i];
-      msg_type |= (dat & 0x7F);
-      // consume
-      i += 1;
-      if ((dat & 0x80) == 0x00) {
-        msg_type_done = true;
-        break;
-      } else {
-        msg_type <<= 7;
-      }
-    }
-    if (!msg_type_done)
-      // not enough data there yet
-      return;
-
-    if (size - i < msg_size)
-      // message body not fully received
-      return;
-
-    // ESP_LOGVV(TAG, "RECV Message: Size=%u Type=%u", msg_size, msg_type);
-
-    if (!this->valid_rx_message_type_(msg_type)) {
-      ESP_LOGE(TAG, "Not a valid message type: %u", msg_type);
-      this->fatal_error_();
-      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);
-  }
-}
-void APIConnection::read_message_(uint32_t size, uint32_t type, uint8_t *msg) {
-  this->last_traffic_ = millis();
-
-  switch (static_cast<APIMessageType>(type)) {
-    case APIMessageType::HELLO_REQUEST: {
-      HelloRequest req;
-      req.decode(msg, size);
-      this->on_hello_request_(req);
-      break;
-    }
-    case APIMessageType::HELLO_RESPONSE: {
-      // Invalid
-      break;
-    }
-    case APIMessageType::CONNECT_REQUEST: {
-      ConnectRequest req;
-      req.decode(msg, size);
-      this->on_connect_request_(req);
-      break;
-    }
-    case APIMessageType::CONNECT_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::DISCONNECT_REQUEST: {
-      DisconnectRequest req;
-      req.decode(msg, size);
-      this->on_disconnect_request_(req);
-      break;
-    }
-    case APIMessageType::DISCONNECT_RESPONSE: {
-      DisconnectResponse req;
-      req.decode(msg, size);
-      this->on_disconnect_response_(req);
-      break;
-    }
-    case APIMessageType::PING_REQUEST: {
-      PingRequest req;
-      req.decode(msg, size);
-      this->on_ping_request_(req);
-      break;
-    }
-    case APIMessageType::PING_RESPONSE: {
-      PingResponse req;
-      req.decode(msg, size);
-      this->on_ping_response_(req);
-      break;
-    }
-    case APIMessageType::DEVICE_INFO_REQUEST: {
-      DeviceInfoRequest req;
-      req.decode(msg, size);
-      this->on_device_info_request_(req);
-      break;
-    }
-    case APIMessageType::DEVICE_INFO_RESPONSE: {
-      // Invalid
-      break;
-    }
-    case APIMessageType::LIST_ENTITIES_REQUEST: {
-      ListEntitiesRequest req;
-      req.decode(msg, size);
-      this->on_list_entities_request_(req);
-      break;
-    }
-    case APIMessageType::LIST_ENTITIES_BINARY_SENSOR_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_COVER_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_FAN_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_LIGHT_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_SENSOR_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_SWITCH_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_TEXT_SENSOR_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_SERVICE_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_CAMERA_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_CLIMATE_RESPONSE:
-    case APIMessageType::LIST_ENTITIES_DONE_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::SUBSCRIBE_STATES_REQUEST: {
-      SubscribeStatesRequest req;
-      req.decode(msg, size);
-      this->on_subscribe_states_request_(req);
-      break;
-    }
-    case APIMessageType::BINARY_SENSOR_STATE_RESPONSE:
-    case APIMessageType::COVER_STATE_RESPONSE:
-    case APIMessageType::FAN_STATE_RESPONSE:
-    case APIMessageType::LIGHT_STATE_RESPONSE:
-    case APIMessageType::SENSOR_STATE_RESPONSE:
-    case APIMessageType::SWITCH_STATE_RESPONSE:
-    case APIMessageType::TEXT_SENSOR_STATE_RESPONSE:
-    case APIMessageType::CAMERA_IMAGE_RESPONSE:
-    case APIMessageType::CLIMATE_STATE_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::SUBSCRIBE_LOGS_REQUEST: {
-      SubscribeLogsRequest req;
-      req.decode(msg, size);
-      this->on_subscribe_logs_request_(req);
-      break;
-    }
-    case APIMessageType ::SUBSCRIBE_LOGS_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::COVER_COMMAND_REQUEST: {
-#ifdef USE_COVER
-      CoverCommandRequest req;
-      req.decode(msg, size);
-      this->on_cover_command_request_(req);
-#endif
-      break;
-    }
-    case APIMessageType::FAN_COMMAND_REQUEST: {
-#ifdef USE_FAN
-      FanCommandRequest req;
-      req.decode(msg, size);
-      this->on_fan_command_request_(req);
-#endif
-      break;
-    }
-    case APIMessageType::LIGHT_COMMAND_REQUEST: {
-#ifdef USE_LIGHT
-      LightCommandRequest req;
-      req.decode(msg, size);
-      this->on_light_command_request_(req);
-#endif
-      break;
-    }
-    case APIMessageType::SWITCH_COMMAND_REQUEST: {
-#ifdef USE_SWITCH
-      SwitchCommandRequest req;
-      req.decode(msg, size);
-      this->on_switch_command_request_(req);
-#endif
-      break;
-    }
-    case APIMessageType::CLIMATE_COMMAND_REQUEST: {
-#ifdef USE_CLIMATE
-      ClimateCommandRequest req;
-      req.decode(msg, size);
-      this->on_climate_command_request_(req);
-#endif
-      break;
-    }
-    case APIMessageType::SUBSCRIBE_SERVICE_CALLS_REQUEST: {
-      SubscribeServiceCallsRequest req;
-      req.decode(msg, size);
-      this->on_subscribe_service_calls_request_(req);
-      break;
-    }
-    case APIMessageType::SERVICE_CALL_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::GET_TIME_REQUEST:
-      // Invalid
-      break;
-    case APIMessageType::GET_TIME_RESPONSE: {
-#ifdef USE_HOMEASSISTANT_TIME
-      homeassistant::GetTimeResponse req;
-      req.decode(msg, size);
-#endif
-      break;
-    }
-    case APIMessageType::SUBSCRIBE_HOME_ASSISTANT_STATES_REQUEST: {
-      SubscribeHomeAssistantStatesRequest req;
-      req.decode(msg, size);
-      this->on_subscribe_home_assistant_states_request_(req);
-      break;
-    }
-    case APIMessageType::SUBSCRIBE_HOME_ASSISTANT_STATE_RESPONSE:
-      // Invalid
-      break;
-    case APIMessageType::HOME_ASSISTANT_STATE_RESPONSE: {
-      HomeAssistantStateResponse req;
-      req.decode(msg, size);
-      this->on_home_assistant_state_response_(req);
-      break;
-    }
-    case APIMessageType::EXECUTE_SERVICE_REQUEST: {
-      ExecuteServiceRequest req;
-      req.decode(msg, size);
-      this->on_execute_service_(req);
-      break;
-    }
-    case APIMessageType::CAMERA_IMAGE_REQUEST: {
-#ifdef USE_ESP32_CAMERA
-      CameraImageRequest req;
-      req.decode(msg, size);
-      this->on_camera_image_request_(req);
-#endif
-      break;
-    }
-  }
-}
-void APIConnection::on_hello_request_(const HelloRequest &req) {
-  ESP_LOGVV(TAG, "on_hello_request_(client_info='%s')", req.get_client_info().c_str());
-  this->client_info_ = req.get_client_info() + " (" + this->client_->remoteIP().toString().c_str();
-  this->client_info_ += ")";
-  ESP_LOGV(TAG, "Hello from client: '%s'", this->client_info_.c_str());
-
-  auto buffer = this->get_buffer();
-  // uint32 api_version_major = 1; -> 1
-  buffer.encode_uint32(1, 1);
-  // uint32 api_version_minor = 2; -> 1
-  buffer.encode_uint32(2, 1);
-
-  // string server_info = 3;
-  buffer.encode_string(3, App.get_name() + " (esphome v" ESPHOME_VERSION ")");
-  bool success = this->send_buffer(APIMessageType::HELLO_RESPONSE);
-  if (!success) {
-    this->fatal_error_();
-    return;
-  }
-
-  this->connection_state_ = ConnectionState::WAITING_FOR_CONNECT;
-}
-void APIConnection::on_connect_request_(const ConnectRequest &req) {
-  ESP_LOGVV(TAG, "on_connect_request_(password='%s')", req.get_password().c_str());
-  bool correct = this->parent_->check_password(req.get_password());
-  auto buffer = this->get_buffer();
-  // bool invalid_password = 1;
-  buffer.encode_bool(1, !correct);
-  bool success = this->send_buffer(APIMessageType::CONNECT_RESPONSE);
-  if (!success) {
-    this->fatal_error_();
-    return;
-  }
-
-  if (correct) {
-    ESP_LOGD(TAG, "Client '%s' connected successfully!", this->client_info_.c_str());
-    this->connection_state_ = ConnectionState::CONNECTED;
-
-#ifdef USE_HOMEASSISTANT_TIME
-    if (homeassistant::global_homeassistant_time != nullptr) {
-      this->send_time_request();
-    }
-#endif
-  }
-}
-void APIConnection::on_disconnect_request_(const DisconnectRequest &req) {
-  ESP_LOGVV(TAG, "on_disconnect_request_");
-  // remote initiated disconnect_client
-  if (!this->send_empty_message(APIMessageType::DISCONNECT_RESPONSE)) {
-    this->fatal_error_();
-    return;
-  }
-  this->disconnect_client();
-}
-void APIConnection::on_disconnect_response_(const DisconnectResponse &req) {
-  ESP_LOGVV(TAG, "on_disconnect_response_");
-  // we initiated disconnect_client
-  this->disconnect_client();
-}
-void APIConnection::on_ping_request_(const PingRequest &req) {
-  ESP_LOGVV(TAG, "on_ping_request_");
-  PingResponse resp;
-  this->send_message(resp);
-}
-void APIConnection::on_ping_response_(const PingResponse &req) {
-  ESP_LOGVV(TAG, "on_ping_response_");
-  // we initiated ping
-  this->sent_ping_ = false;
-}
-void APIConnection::on_device_info_request_(const DeviceInfoRequest &req) {
-  ESP_LOGVV(TAG, "on_device_info_request_");
-  auto buffer = this->get_buffer();
-  // bool uses_password = 1;
-  buffer.encode_bool(1, this->parent_->uses_password());
-  // string name = 2;
-  buffer.encode_string(2, App.get_name());
-  // string mac_address = 3;
-  buffer.encode_string(3, get_mac_address_pretty());
-  // string esphome_version = 4;
-  buffer.encode_string(4, ESPHOME_VERSION);
-  // string compilation_time = 5;
-  buffer.encode_string(5, App.get_compilation_time());
-#ifdef ARDUINO_BOARD
-  // string model = 6;
-  buffer.encode_string(6, ARDUINO_BOARD);
-#endif
-#ifdef USE_DEEP_SLEEP
-  // bool has_deep_sleep = 7;
-  buffer.encode_bool(7, deep_sleep::global_has_deep_sleep);
-#endif
-  this->send_buffer(APIMessageType::DEVICE_INFO_RESPONSE);
-}
-void APIConnection::on_list_entities_request_(const ListEntitiesRequest &req) {
-  ESP_LOGVV(TAG, "on_list_entities_request_");
-  this->list_entities_iterator_.begin();
-}
-void APIConnection::on_subscribe_states_request_(const SubscribeStatesRequest &req) {
-  ESP_LOGVV(TAG, "on_subscribe_states_request_");
-  this->state_subscription_ = true;
-  this->initial_state_iterator_.begin();
-}
-void APIConnection::on_subscribe_logs_request_(const SubscribeLogsRequest &req) {
-  ESP_LOGVV(TAG, "on_subscribe_logs_request_");
-  this->log_subscription_ = req.get_level();
-  if (req.get_dump_config()) {
-    App.schedule_dump_config();
-  }
-}
-
-void APIConnection::fatal_error_() {
-  this->client_->close();
-  this->remove_ = true;
-}
-bool APIConnection::valid_rx_message_type_(uint32_t type) {
-  switch (static_cast<APIMessageType>(type)) {
-    case APIMessageType::HELLO_RESPONSE:
-    case APIMessageType::CONNECT_RESPONSE:
-      return false;
-    case APIMessageType::HELLO_REQUEST:
-      return this->connection_state_ == ConnectionState::WAITING_FOR_HELLO;
-    case APIMessageType::CONNECT_REQUEST:
-      return this->connection_state_ == ConnectionState::WAITING_FOR_CONNECT;
-    case APIMessageType::PING_REQUEST:
-    case APIMessageType::PING_RESPONSE:
-    case APIMessageType::DISCONNECT_REQUEST:
-    case APIMessageType::DISCONNECT_RESPONSE:
-    case APIMessageType::DEVICE_INFO_REQUEST:
-      if (this->connection_state_ == ConnectionState::WAITING_FOR_CONNECT)
-        return true;
-    default:
-      return this->connection_state_ == ConnectionState::CONNECTED;
-  }
-}
-bool APIConnection::send_message(APIMessage &msg) {
-  this->send_buffer_.clear();
-  APIBuffer buf(&this->send_buffer_);
-  msg.encode(buf);
-  return this->send_buffer(msg.message_type());
-}
-bool APIConnection::send_empty_message(APIMessageType type) {
-  this->send_buffer_.clear();
-  return this->send_buffer(type);
-}
-
-void APIConnection::disconnect_client() {
-  this->client_->close();
-  this->remove_ = true;
-}
-void encode_varint(uint8_t *dat, uint8_t *len, uint32_t value) {
-  if (value <= 0x7F) {
-    *dat = value;
-    (*len)++;
-    return;
-  }
-
-  while (value) {
-    uint8_t temp = value & 0x7F;
-    value >>= 7;
-    if (value) {
-      *dat = temp | 0x80;
-    } else {
-      *dat = temp;
-    }
-    dat++;
-    (*len)++;
-  }
-}
-
-bool APIConnection::send_buffer(APIMessageType type) {
-  uint8_t header[20];
-  header[0] = 0x00;
-  uint8_t header_len = 1;
-  encode_varint(header + header_len, &header_len, this->send_buffer_.size());
-  encode_varint(header + header_len, &header_len, static_cast<uint32_t>(type));
-
-  size_t needed_space = this->send_buffer_.size() + header_len;
-
-  if (needed_space > this->client_->space()) {
-    delay(5);
-    if (needed_space > this->client_->space()) {
-      if (type != APIMessageType::SUBSCRIBE_LOGS_RESPONSE) {
-        ESP_LOGV(TAG, "Cannot send message because of TCP buffer space");
-      }
-      delay(5);
-      return false;
-    }
-  }
-
-  //  char buffer[512];
-  //  uint32_t offset = 0;
-  //  for (int j = 0; j < header_len; j++) {
-  //    offset += snprintf(buffer + offset, 512 - offset, "0x%02X ", header[j]);
-  //  }
-  //  offset += snprintf(buffer + offset, 512 - offset, "| ");
-  //  for (auto &it : this->send_buffer_) {
-  //    int i = snprintf(buffer + offset, 512 - offset, "0x%02X ", it);
-  //    if (i <= 0)
-  //      break;
-  //    offset += i;
-  //  }
-  //  ESP_LOGVV(TAG, "SEND %s", buffer);
-
-  this->client_->add(reinterpret_cast<char *>(header), header_len);
-  this->client_->add(reinterpret_cast<char *>(this->send_buffer_.data()), this->send_buffer_.size());
-  return this->client_->send();
-}
-
-void APIConnection::loop() {
-  if (!network_is_connected()) {
-    // when network is disconnected force disconnect immediately
-    // don't wait for timeout
-    this->fatal_error_();
-    return;
-  }
-  if (this->client_->disconnected()) {
-    // failsafe for disconnect logic
-    this->on_disconnect_();
-    return;
-  }
-  this->parse_recv_buffer_();
-
-  this->list_entities_iterator_.advance();
-  this->initial_state_iterator_.advance();
-
-  const uint32_t keepalive = 60000;
-  if (this->sent_ping_) {
-    if (millis() - this->last_traffic_ > (keepalive * 3) / 2) {
-      ESP_LOGW(TAG, "'%s' didn't respond to ping request in time. Disconnecting...", this->client_info_.c_str());
-      this->disconnect_client();
-    }
-  } else if (millis() - this->last_traffic_ > keepalive) {
-    this->sent_ping_ = true;
-    this->send_ping_request();
-  }
-
-#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->get_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(APIMessageType::CAMERA_IMAGE_RESPONSE);
-      if (success) {
-        this->image_reader_.consume_data(to_send);
-      }
-      if (success && done) {
-        this->image_reader_.return_image();
-      }
-    }
-  }
-#endif
-}
-
-#ifdef USE_BINARY_SENSOR
-bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, binary_sensor->get_object_id_hash());
-  // bool state = 2;
-  buffer.encode_bool(2, state);
-  return this->send_buffer(APIMessageType::BINARY_SENSOR_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_COVER
-bool APIConnection::send_cover_state(cover::Cover *cover) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  auto traits = cover->get_traits();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, cover->get_object_id_hash());
-  // enum LegacyCoverState {
-  //   OPEN = 0;
-  //   CLOSED = 1;
-  // }
-  // LegacyCoverState legacy_state = 2;
-  uint32_t state = (cover->position == cover::COVER_OPEN) ? 0 : 1;
-  buffer.encode_uint32(2, state);
-  // float position = 3;
-  buffer.encode_float(3, cover->position);
-  if (traits.get_supports_tilt()) {
-    // float tilt = 4;
-    buffer.encode_float(4, cover->tilt);
-  }
-  // enum CoverCurrentOperation {
-  //   IDLE = 0;
-  //   IS_OPENING = 1;
-  //   IS_CLOSING = 2;
-  // }
-  // CoverCurrentOperation current_operation = 5;
-  buffer.encode_uint32(5, cover->current_operation);
-  return this->send_buffer(APIMessageType::COVER_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_FAN
-bool APIConnection::send_fan_state(fan::FanState *fan) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, fan->get_object_id_hash());
-  // bool state = 2;
-  buffer.encode_bool(2, fan->state);
-  // bool oscillating = 3;
-  if (fan->get_traits().supports_oscillation()) {
-    buffer.encode_bool(3, fan->oscillating);
-  }
-  // enum FanSpeed {
-  //   LOW = 0;
-  //   MEDIUM = 1;
-  //   HIGH = 2;
-  // }
-  // FanSpeed speed = 4;
-  if (fan->get_traits().supports_speed()) {
-    buffer.encode_uint32(4, fan->speed);
-  }
-  return this->send_buffer(APIMessageType::FAN_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_LIGHT
-bool APIConnection::send_light_state(light::LightState *light) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  auto traits = light->get_traits();
-  auto values = light->remote_values;
-
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, light->get_object_id_hash());
-  // bool state = 2;
-  buffer.encode_bool(2, values.get_state() != 0.0f);
-  // float brightness = 3;
-  if (traits.get_supports_brightness()) {
-    buffer.encode_float(3, values.get_brightness());
-  }
-  if (traits.get_supports_rgb()) {
-    // float red = 4;
-    buffer.encode_float(4, values.get_red());
-    // float green = 5;
-    buffer.encode_float(5, values.get_green());
-    // float blue = 6;
-    buffer.encode_float(6, values.get_blue());
-  }
-  // float white = 7;
-  if (traits.get_supports_rgb_white_value()) {
-    buffer.encode_float(7, values.get_white());
-  }
-  // float color_temperature = 8;
-  if (traits.get_supports_color_temperature()) {
-    buffer.encode_float(8, values.get_color_temperature());
-  }
-  // string effect = 9;
-  if (light->supports_effects()) {
-    buffer.encode_string(9, light->get_effect_name());
-  }
-  return this->send_buffer(APIMessageType::LIGHT_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_SENSOR
-bool APIConnection::send_sensor_state(sensor::Sensor *sensor, float state) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, sensor->get_object_id_hash());
-  // float state = 2;
-  buffer.encode_float(2, state);
-  return this->send_buffer(APIMessageType::SENSOR_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_SWITCH
-bool APIConnection::send_switch_state(switch_::Switch *a_switch, bool state) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, a_switch->get_object_id_hash());
-  // bool state = 2;
-  buffer.encode_bool(2, state);
-  return this->send_buffer(APIMessageType::SWITCH_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_TEXT_SENSOR
-bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, text_sensor->get_object_id_hash());
-  // string state = 2;
-  buffer.encode_string(2, state);
-  return this->send_buffer(APIMessageType::TEXT_SENSOR_STATE_RESPONSE);
-}
-#endif
-
-#ifdef USE_CLIMATE
-bool APIConnection::send_climate_state(climate::Climate *climate) {
-  if (!this->state_subscription_)
-    return false;
-
-  auto buffer = this->get_buffer();
-  auto traits = climate->get_traits();
-  // fixed32 key = 1;
-  buffer.encode_fixed32(1, climate->get_object_id_hash());
-  // ClimateMode mode = 2;
-  buffer.encode_uint32(2, static_cast<uint32_t>(climate->mode));
-  // float current_temperature = 3;
-  if (traits.get_supports_current_temperature()) {
-    buffer.encode_float(3, climate->current_temperature);
-  }
-  if (traits.get_supports_two_point_target_temperature()) {
-    // float target_temperature_low = 5;
-    buffer.encode_float(5, climate->target_temperature_low);
-    // float target_temperature_high = 6;
-    buffer.encode_float(6, climate->target_temperature_high);
-  } else {
-    // float target_temperature = 4;
-    buffer.encode_float(4, climate->target_temperature);
-  }
-  // bool away = 7;
-  if (traits.get_supports_away()) {
-    buffer.encode_bool(7, climate->away);
-  }
-  return this->send_buffer(APIMessageType::CLIMATE_STATE_RESPONSE);
-}
-#endif
-
-bool APIConnection::send_log_message(int level, const char *tag, const char *line) {
-  if (this->log_subscription_ < level)
-    return false;
-
-  auto buffer = this->get_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));
-  bool success = this->send_buffer(APIMessageType::SUBSCRIBE_LOGS_RESPONSE);
-
-  if (!success) {
-    buffer = this->get_buffer();
-    // bool send_failed = 4;
-    buffer.encode_bool(4, true);
-    return this->send_buffer(APIMessageType::SUBSCRIBE_LOGS_RESPONSE);
-  } else {
-    return true;
-  }
-}
-bool APIConnection::send_disconnect_request() {
-  DisconnectRequest req;
-  return this->send_message(req);
-}
-bool APIConnection::send_ping_request() {
-  ESP_LOGVV(TAG, "Sending ping...");
-  PingRequest req;
-  return this->send_message(req);
-}
-
-#ifdef USE_COVER
-void APIConnection::on_cover_command_request_(const CoverCommandRequest &req) {
-  ESP_LOGVV(TAG, "on_cover_command_request_");
-  cover::Cover *cover = App.get_cover_by_key(req.get_key());
-  if (cover == nullptr)
-    return;
-
-  auto call = cover->make_call();
-  if (req.get_legacy_command().has_value()) {
-    auto cmd = *req.get_legacy_command();
-    switch (cmd) {
-      case LEGACY_COVER_COMMAND_OPEN:
-        call.set_command_open();
-        break;
-      case LEGACY_COVER_COMMAND_CLOSE:
-        call.set_command_close();
-        break;
-      case LEGACY_COVER_COMMAND_STOP:
-        call.set_command_stop();
-        break;
-    }
-  }
-  if (req.get_position().has_value()) {
-    auto pos = *req.get_position();
-    call.set_position(pos);
-  }
-  if (req.get_tilt().has_value()) {
-    auto tilt = *req.get_tilt();
-    call.set_tilt(tilt);
-  }
-  if (req.get_stop()) {
-    call.set_command_stop();
-  }
-  call.perform();
-}
-#endif
-
-#ifdef USE_FAN
-void APIConnection::on_fan_command_request_(const FanCommandRequest &req) {
-  ESP_LOGVV(TAG, "on_fan_command_request_");
-  fan::FanState *fan = App.get_fan_by_key(req.get_key());
-  if (fan == nullptr)
-    return;
-
-  auto call = fan->make_call();
-  call.set_state(req.get_state());
-  call.set_oscillating(req.get_oscillating());
-  call.set_speed(req.get_speed());
-  call.perform();
-}
-#endif
-
-#ifdef USE_LIGHT
-void APIConnection::on_light_command_request_(const LightCommandRequest &req) {
-  ESP_LOGVV(TAG, "on_light_command_request_");
-  light::LightState *light = App.get_light_by_key(req.get_key());
-  if (light == nullptr)
-    return;
-
-  auto call = light->make_call();
-  call.set_state(req.get_state());
-  call.set_brightness(req.get_brightness());
-  call.set_red(req.get_red());
-  call.set_green(req.get_green());
-  call.set_blue(req.get_blue());
-  call.set_white(req.get_white());
-  call.set_color_temperature(req.get_color_temperature());
-  call.set_transition_length(req.get_transition_length());
-  call.set_flash_length(req.get_flash_length());
-  call.set_effect(req.get_effect());
-  call.perform();
-}
-#endif
-
-#ifdef USE_SWITCH
-void APIConnection::on_switch_command_request_(const SwitchCommandRequest &req) {
-  ESP_LOGVV(TAG, "on_switch_command_request_");
-  switch_::Switch *a_switch = App.get_switch_by_key(req.get_key());
-  if (a_switch == nullptr || a_switch->is_internal())
-    return;
-
-  if (req.get_state()) {
-    a_switch->turn_on();
-  } else {
-    a_switch->turn_off();
-  }
-}
-#endif
-
-#ifdef USE_CLIMATE
-void APIConnection::on_climate_command_request_(const ClimateCommandRequest &req) {
-  ESP_LOGVV(TAG, "on_climate_command_request_");
-  climate::Climate *climate = App.get_climate_by_key(req.get_key());
-  if (climate == nullptr)
-    return;
-
-  auto call = climate->make_call();
-  if (req.get_mode().has_value())
-    call.set_mode(*req.get_mode());
-  if (req.get_target_temperature().has_value())
-    call.set_target_temperature(*req.get_target_temperature());
-  if (req.get_target_temperature_low().has_value())
-    call.set_target_temperature_low(*req.get_target_temperature_low());
-  if (req.get_target_temperature_high().has_value())
-    call.set_target_temperature_high(*req.get_target_temperature_high());
-  if (req.get_away().has_value())
-    call.set_away(*req.get_away());
-  call.perform();
-}
-#endif
-
-void APIConnection::on_subscribe_service_calls_request_(const SubscribeServiceCallsRequest &req) {
-  this->service_call_subscription_ = true;
-}
-void APIConnection::send_service_call(ServiceCallResponse &call) {
-  if (!this->service_call_subscription_)
-    return;
-
-  this->send_message(call);
-}
-void APIConnection::on_subscribe_home_assistant_states_request_(const SubscribeHomeAssistantStatesRequest &req) {
-  for (auto &it : this->parent_->get_state_subs()) {
-    auto buffer = this->get_buffer();
-    // string entity_id = 1;
-    buffer.encode_string(1, it.entity_id);
-    this->send_buffer(APIMessageType::SUBSCRIBE_HOME_ASSISTANT_STATE_RESPONSE);
-  }
-}
-void APIConnection::on_home_assistant_state_response_(const HomeAssistantStateResponse &req) {
-  for (auto &it : this->parent_->get_state_subs()) {
-    if (it.entity_id == req.get_entity_id()) {
-      it.callback(req.get_state());
-    }
-  }
-}
-void APIConnection::on_execute_service_(const ExecuteServiceRequest &req) {
-  ESP_LOGVV(TAG, "on_execute_service_");
-  bool found = false;
-  for (auto *service : this->parent_->get_user_services()) {
-    if (service->execute_service(req)) {
-      found = true;
-    }
-  }
-  if (!found) {
-    ESP_LOGV(TAG, "Could not find matching service!");
-  }
-}
-
-APIBuffer APIConnection::get_buffer() {
-  this->send_buffer_.clear();
-  return {&this->send_buffer_};
-}
-#ifdef USE_HOMEASSISTANT_TIME
-void APIConnection::send_time_request() { this->send_empty_message(APIMessageType::GET_TIME_REQUEST); }
-#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);
-}
-#endif
-
-#ifdef USE_ESP32_CAMERA
-void APIConnection::on_camera_image_request_(const CameraImageRequest &req) {
-  if (esp32_camera::global_esp32_camera == nullptr)
-    return;
-
-  ESP_LOGV(TAG, "on_camera_image_request_ stream=%s single=%s", YESNO(req.get_stream()), YESNO(req.get_single()));
-  if (req.get_single()) {
-    esp32_camera::global_esp32_camera->request_image();
-  }
-  if (req.get_stream()) {
-    esp32_camera::global_esp32_camera->request_stream();
-  }
-}
-#endif
-
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_server.h

@@ -4,14 +4,12 @@
 #include "esphome/core/controller.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/log.h"
+#include "api_pb2.h"
+#include "api_pb2_service.h"
 #include "util.h"
-#include "api_message.h"
-#include "basic_messages.h"
 #include "list_entities.h"
 #include "subscribe_state.h"
-#include "subscribe_logs.h"
-#include "command_messages.h"
-#include "service_call_message.h"
+#include "homeassistant_service.h"
 #include "user_services.h"
 
 #ifdef ARDUINO_ARCH_ESP32
@@ -24,130 +22,6 @@
 namespace esphome {
 namespace api {
 
-class APIServer;
-
-class APIConnection {
- public:
-  APIConnection(AsyncClient *client, APIServer *parent);
-  ~APIConnection();
-
-  void disconnect_client();
-  APIBuffer get_buffer();
-  bool send_buffer(APIMessageType type);
-  bool send_message(APIMessage &msg);
-  bool send_empty_message(APIMessageType type);
-  void loop();
-
-#ifdef USE_BINARY_SENSOR
-  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
-#endif
-#ifdef USE_COVER
-  bool send_cover_state(cover::Cover *cover);
-#endif
-#ifdef USE_FAN
-  bool send_fan_state(fan::FanState *fan);
-#endif
-#ifdef USE_LIGHT
-  bool send_light_state(light::LightState *light);
-#endif
-#ifdef USE_SENSOR
-  bool send_sensor_state(sensor::Sensor *sensor, float state);
-#endif
-#ifdef USE_SWITCH
-  bool send_switch_state(switch_::Switch *a_switch, bool state);
-#endif
-#ifdef USE_TEXT_SENSOR
-  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state);
-#endif
-#ifdef USE_ESP32_CAMERA
-  void send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
-#endif
-#ifdef USE_CLIMATE
-  bool send_climate_state(climate::Climate *climate);
-#endif
-  bool send_log_message(int level, const char *tag, const char *line);
-  bool send_disconnect_request();
-  bool send_ping_request();
-  void send_service_call(ServiceCallResponse &call);
-#ifdef USE_HOMEASSISTANT_TIME
-  void send_time_request();
-#endif
-
- 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 fatal_error_();
-  bool valid_rx_message_type_(uint32_t msg_type);
-  void read_message_(uint32_t size, uint32_t type, uint8_t *msg);
-  void parse_recv_buffer_();
-
-  // request types
-  void on_hello_request_(const HelloRequest &req);
-  void on_connect_request_(const ConnectRequest &req);
-  void on_disconnect_request_(const DisconnectRequest &req);
-  void on_disconnect_response_(const DisconnectResponse &req);
-  void on_ping_request_(const PingRequest &req);
-  void on_ping_response_(const PingResponse &req);
-  void on_device_info_request_(const DeviceInfoRequest &req);
-  void on_list_entities_request_(const ListEntitiesRequest &req);
-  void on_subscribe_states_request_(const SubscribeStatesRequest &req);
-  void on_subscribe_logs_request_(const SubscribeLogsRequest &req);
-#ifdef USE_COVER
-  void on_cover_command_request_(const CoverCommandRequest &req);
-#endif
-#ifdef USE_FAN
-  void on_fan_command_request_(const FanCommandRequest &req);
-#endif
-#ifdef USE_LIGHT
-  void on_light_command_request_(const LightCommandRequest &req);
-#endif
-#ifdef USE_SWITCH
-  void on_switch_command_request_(const SwitchCommandRequest &req);
-#endif
-#ifdef USE_CLIMATE
-  void on_climate_command_request_(const ClimateCommandRequest &req);
-#endif
-  void on_subscribe_service_calls_request_(const SubscribeServiceCallsRequest &req);
-  void on_subscribe_home_assistant_states_request_(const SubscribeHomeAssistantStatesRequest &req);
-  void on_home_assistant_state_response_(const HomeAssistantStateResponse &req);
-  void on_execute_service_(const ExecuteServiceRequest &req);
-#ifdef USE_ESP32_CAMERA
-  void on_camera_image_request_(const CameraImageRequest &req);
-#endif
-
-  enum class ConnectionState {
-    WAITING_FOR_HELLO,
-    WAITING_FOR_CONNECT,
-    CONNECTED,
-  } connection_state_{ConnectionState::WAITING_FOR_HELLO};
-
-  bool remove_{false};
-
-  std::vector<uint8_t> send_buffer_;
-  std::vector<uint8_t> recv_buffer_;
-
-  std::string client_info_;
-#ifdef USE_ESP32_CAMERA
-  esp32_camera::CameraImageReader image_reader_;
-#endif
-
-  bool state_subscription_{false};
-  int log_subscription_{ESPHOME_LOG_LEVEL_NONE};
-  uint32_t last_traffic_;
-  bool sent_ping_{false};
-  bool service_call_subscription_{false};
-  AsyncClient *client_;
-  APIServer *parent_;
-  InitialStateIterator initial_state_iterator_;
-  ListEntitiesIterator list_entities_iterator_;
-};
-
-template<typename... Ts> class HomeAssistantServiceCallAction;
-
 class APIServer : public Component, public Controller {
  public:
   APIServer();
@@ -187,7 +61,7 @@ class APIServer : public Component, public Controller {
 #ifdef USE_CLIMATE
   void on_climate_update(climate::Climate *obj) override;
 #endif
-  void send_service_call(ServiceCallResponse &call);
+  void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
 #ifdef USE_HOMEASSISTANT_TIME
   void request_time();
@@ -197,10 +71,12 @@ class APIServer : public Component, public Controller {
 
   struct HomeAssistantStateSubscription {
     std::string entity_id;
+    optional<std::string> attribute;
     std::function<void(std::string)> callback;
   };
 
-  void subscribe_home_assistant_state(std::string entity_id, std::function<void(std::string)> f);
+  void subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,
+                                      std::function<void(std::string)> f);
   const std::vector<HomeAssistantStateSubscription> &get_state_subs() const;
   const std::vector<UserServiceDescriptor *> &get_user_services() const { return this->user_services_; }
 
@@ -217,22 +93,6 @@ class APIServer : public Component, public Controller {
 
 extern APIServer *global_api_server;
 
-template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts...> {
- public:
-  explicit HomeAssistantServiceCallAction(APIServer *parent) : parent_(parent) {}
-  void set_service(const std::string &service) { this->resp_.set_service(service); }
-  void set_data(const std::vector<KeyValuePair> &data) { this->resp_.set_data(data); }
-  void set_data_template(const std::vector<KeyValuePair> &data_template) {
-    this->resp_.set_data_template(data_template);
-  }
-  void set_variables(const std::vector<TemplatableKeyValuePair> &variables) { this->resp_.set_variables(variables); }
-  void play(Ts... x) override { this->parent_->send_service_call(this->resp_); }
-
- protected:
-  APIServer *parent_;
-  ServiceCallResponse resp_;
-};
-
 template<typename... Ts> class APIConnectedCondition : public Condition<Ts...> {
  public:
   bool check(Ts... x) override { return global_api_server->is_connected(); }

esphome/components/api/basic_messages.cpp

@@ -1,57 +0,0 @@
-#include "basic_messages.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace api {
-
-// Hello
-bool HelloRequest::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 1:  // string client_info = 1;
-      this->client_info_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
-}
-const std::string &HelloRequest::get_client_info() const { return this->client_info_; }
-void HelloRequest::set_client_info(const std::string &client_info) { this->client_info_ = client_info; }
-APIMessageType HelloRequest::message_type() const { return APIMessageType::HELLO_REQUEST; }
-
-// Connect
-bool ConnectRequest::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 1:  // string password = 1;
-      this->password_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
-}
-const std::string &ConnectRequest::get_password() const { return this->password_; }
-void ConnectRequest::set_password(const std::string &password) { this->password_ = password; }
-APIMessageType ConnectRequest::message_type() const { return APIMessageType::CONNECT_REQUEST; }
-
-APIMessageType DeviceInfoRequest::message_type() const { return APIMessageType::DEVICE_INFO_REQUEST; }
-APIMessageType DisconnectRequest::message_type() const { return APIMessageType::DISCONNECT_REQUEST; }
-bool DisconnectRequest::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 1:  // string reason = 1;
-      this->reason_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
-}
-const std::string &DisconnectRequest::get_reason() const { return this->reason_; }
-void DisconnectRequest::set_reason(const std::string &reason) { this->reason_ = reason; }
-void DisconnectRequest::encode(APIBuffer &buffer) {
-  // string reason = 1;
-  buffer.encode_string(1, this->reason_);
-}
-APIMessageType DisconnectResponse::message_type() const { return APIMessageType::DISCONNECT_RESPONSE; }
-APIMessageType PingRequest::message_type() const { return APIMessageType::PING_REQUEST; }
-APIMessageType PingResponse::message_type() const { return APIMessageType::PING_RESPONSE; }
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/basic_messages.h

@@ -1,63 +0,0 @@
-#pragma once
-
-#include "api_message.h"
-
-namespace esphome {
-namespace api {
-
-class HelloRequest : public APIMessage {
- public:
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  const std::string &get_client_info() const;
-  void set_client_info(const std::string &client_info);
-  APIMessageType message_type() const override;
-
- protected:
-  std::string client_info_;
-};
-
-class ConnectRequest : public APIMessage {
- public:
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  const std::string &get_password() const;
-  void set_password(const std::string &password);
-  APIMessageType message_type() const override;
-
- protected:
-  std::string password_;
-};
-
-class DeviceInfoRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-class DisconnectRequest : public APIMessage {
- public:
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  void encode(APIBuffer &buffer) override;
-  APIMessageType message_type() const override;
-  const std::string &get_reason() const;
-  void set_reason(const std::string &reason);
-
- protected:
-  std::string reason_;
-};
-
-class DisconnectResponse : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-class PingRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-class PingResponse : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/command_messages.cpp

@@ -1,417 +0,0 @@
-#include "command_messages.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace api {
-
-#ifdef USE_COVER
-bool CoverCommandRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 2:
-      // bool has_legacy_command = 2;
-      this->has_legacy_command_ = value;
-      return true;
-    case 3:
-      // enum LegacyCoverCommand {
-      //   OPEN = 0;
-      //   CLOSE = 1;
-      //   STOP = 2;
-      // }
-      // LegacyCoverCommand legacy_command_ = 3;
-      this->legacy_command_ = static_cast<LegacyCoverCommand>(value);
-      return true;
-    case 4:
-      // bool has_position = 4;
-      this->has_position_ = value;
-      return true;
-    case 6:
-      // bool has_tilt = 6;
-      this->has_tilt_ = value;
-      return true;
-    case 8:
-      // bool stop = 8;
-      this->stop_ = value;
-    default:
-      return false;
-  }
-}
-bool CoverCommandRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    case 5:
-      // float position = 5;
-      this->position_ = as_float(value);
-      return true;
-    case 7:
-      // float tilt = 7;
-      this->tilt_ = as_float(value);
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType CoverCommandRequest::message_type() const { return APIMessageType ::COVER_COMMAND_REQUEST; }
-uint32_t CoverCommandRequest::get_key() const { return this->key_; }
-optional<LegacyCoverCommand> CoverCommandRequest::get_legacy_command() const {
-  if (!this->has_legacy_command_)
-    return {};
-  return this->legacy_command_;
-}
-optional<float> CoverCommandRequest::get_position() const {
-  if (!this->has_position_)
-    return {};
-  return this->position_;
-}
-optional<float> CoverCommandRequest::get_tilt() const {
-  if (!this->has_tilt_)
-    return {};
-  return this->tilt_;
-}
-#endif
-
-#ifdef USE_FAN
-bool FanCommandRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 2:
-      // bool has_state = 2;
-      this->has_state_ = value;
-      return true;
-    case 3:
-      // bool state = 3;
-      this->state_ = value;
-      return true;
-    case 4:
-      // bool has_speed = 4;
-      this->has_speed_ = value;
-      return true;
-    case 5:
-      // FanSpeed speed = 5;
-      this->speed_ = static_cast<fan::FanSpeed>(value);
-      return true;
-    case 6:
-      // bool has_oscillating = 6;
-      this->has_oscillating_ = value;
-      return true;
-    case 7:
-      // bool oscillating = 7;
-      this->oscillating_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-bool FanCommandRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType FanCommandRequest::message_type() const { return APIMessageType::FAN_COMMAND_REQUEST; }
-uint32_t FanCommandRequest::get_key() const { return this->key_; }
-optional<bool> FanCommandRequest::get_state() const {
-  if (!this->has_state_)
-    return {};
-  return this->state_;
-}
-optional<fan::FanSpeed> FanCommandRequest::get_speed() const {
-  if (!this->has_speed_)
-    return {};
-  return this->speed_;
-}
-optional<bool> FanCommandRequest::get_oscillating() const {
-  if (!this->has_oscillating_)
-    return {};
-  return this->oscillating_;
-}
-#endif
-
-#ifdef USE_LIGHT
-bool LightCommandRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 2:
-      // bool has_state = 2;
-      this->has_state_ = value;
-      return true;
-    case 3:
-      // bool state = 3;
-      this->state_ = value;
-      return true;
-    case 4:
-      // bool has_brightness = 4;
-      this->has_brightness_ = value;
-      return true;
-    case 6:
-      // bool has_rgb = 6;
-      this->has_rgb_ = value;
-      return true;
-    case 10:
-      // bool has_white = 10;
-      this->has_white_ = value;
-      return true;
-    case 12:
-      // bool has_color_temperature = 12;
-      this->has_color_temperature_ = value;
-      return true;
-    case 14:
-      // bool has_transition_length = 14;
-      this->has_transition_length_ = value;
-      return true;
-    case 15:
-      // uint32 transition_length = 15;
-      this->transition_length_ = value;
-      return true;
-    case 16:
-      // bool has_flash_length = 16;
-      this->has_flash_length_ = value;
-      return true;
-    case 17:
-      // uint32 flash_length = 17;
-      this->flash_length_ = value;
-      return true;
-    case 18:
-      // bool has_effect = 18;
-      this->has_effect_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-bool LightCommandRequest::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 19:
-      // string effect = 19;
-      this->effect_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
-}
-bool LightCommandRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    case 5:
-      // float brightness = 5;
-      this->brightness_ = as_float(value);
-      return true;
-    case 7:
-      // float red = 7;
-      this->red_ = as_float(value);
-      return true;
-    case 8:
-      // float green = 8;
-      this->green_ = as_float(value);
-      return true;
-    case 9:
-      // float blue = 9;
-      this->blue_ = as_float(value);
-      return true;
-    case 11:
-      // float white = 11;
-      this->white_ = as_float(value);
-      return true;
-    case 13:
-      // float color_temperature = 13;
-      this->color_temperature_ = as_float(value);
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType LightCommandRequest::message_type() const { return APIMessageType::LIGHT_COMMAND_REQUEST; }
-uint32_t LightCommandRequest::get_key() const { return this->key_; }
-optional<bool> LightCommandRequest::get_state() const {
-  if (!this->has_state_)
-    return {};
-  return this->state_;
-}
-optional<float> LightCommandRequest::get_brightness() const {
-  if (!this->has_brightness_)
-    return {};
-  return this->brightness_;
-}
-optional<float> LightCommandRequest::get_red() const {
-  if (!this->has_rgb_)
-    return {};
-  return this->red_;
-}
-optional<float> LightCommandRequest::get_green() const {
-  if (!this->has_rgb_)
-    return {};
-  return this->green_;
-}
-optional<float> LightCommandRequest::get_blue() const {
-  if (!this->has_rgb_)
-    return {};
-  return this->blue_;
-}
-optional<float> LightCommandRequest::get_white() const {
-  if (!this->has_white_)
-    return {};
-  return this->white_;
-}
-optional<float> LightCommandRequest::get_color_temperature() const {
-  if (!this->has_color_temperature_)
-    return {};
-  return this->color_temperature_;
-}
-optional<uint32_t> LightCommandRequest::get_transition_length() const {
-  if (!this->has_transition_length_)
-    return {};
-  return this->transition_length_;
-}
-optional<uint32_t> LightCommandRequest::get_flash_length() const {
-  if (!this->has_flash_length_)
-    return {};
-  return this->flash_length_;
-}
-optional<std::string> LightCommandRequest::get_effect() const {
-  if (!this->has_effect_)
-    return {};
-  return this->effect_;
-}
-#endif
-
-#ifdef USE_SWITCH
-bool SwitchCommandRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 2:
-      // bool state = 2;
-      this->state_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-bool SwitchCommandRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType SwitchCommandRequest::message_type() const { return APIMessageType::SWITCH_COMMAND_REQUEST; }
-uint32_t SwitchCommandRequest::get_key() const { return this->key_; }
-bool SwitchCommandRequest::get_state() const { return this->state_; }
-#endif
-
-#ifdef USE_ESP32_CAMERA
-bool CameraImageRequest::get_single() const { return this->single_; }
-bool CameraImageRequest::get_stream() const { return this->stream_; }
-bool CameraImageRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // bool single = 1;
-      this->single_ = value;
-      return true;
-    case 2:
-      // bool stream = 2;
-      this->stream_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType CameraImageRequest::message_type() const { return APIMessageType::CAMERA_IMAGE_REQUEST; }
-#endif
-
-#ifdef USE_CLIMATE
-bool ClimateCommandRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 2:
-      // bool has_mode = 2;
-      this->has_mode_ = value;
-      return true;
-    case 3:
-      // ClimateMode mode = 3;
-      this->mode_ = static_cast<climate::ClimateMode>(value);
-      return true;
-    case 4:
-      // bool has_target_temperature = 4;
-      this->has_target_temperature_ = value;
-      return true;
-    case 6:
-      // bool has_target_temperature_low = 6;
-      this->has_target_temperature_low_ = value;
-      return true;
-    case 8:
-      // bool has_target_temperature_high = 8;
-      this->has_target_temperature_high_ = value;
-      return true;
-    case 10:
-      // bool has_away = 10;
-      this->has_away_ = value;
-      return true;
-    case 11:
-      // bool away = 11;
-      this->away_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-bool ClimateCommandRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:
-      // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    case 5:
-      // float target_temperature = 5;
-      this->target_temperature_ = as_float(value);
-      return true;
-    case 7:
-      // float target_temperature_low = 7;
-      this->target_temperature_low_ = as_float(value);
-      return true;
-    case 9:
-      // float target_temperature_high = 9;
-      this->target_temperature_high_ = as_float(value);
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType ClimateCommandRequest::message_type() const { return APIMessageType::CLIMATE_COMMAND_REQUEST; }
-uint32_t ClimateCommandRequest::get_key() const { return this->key_; }
-optional<climate::ClimateMode> ClimateCommandRequest::get_mode() const {
-  if (!this->has_mode_)
-    return {};
-  return this->mode_;
-}
-optional<float> ClimateCommandRequest::get_target_temperature() const {
-  if (!this->has_target_temperature_)
-    return {};
-  return this->target_temperature_;
-}
-optional<float> ClimateCommandRequest::get_target_temperature_low() const {
-  if (!this->has_target_temperature_low_)
-    return {};
-  return this->target_temperature_low_;
-}
-optional<float> ClimateCommandRequest::get_target_temperature_high() const {
-  if (!this->has_target_temperature_high_)
-    return {};
-  return this->target_temperature_high_;
-}
-optional<bool> ClimateCommandRequest::get_away() const {
-  if (!this->has_away_)
-    return {};
-  return this->away_;
-}
-#endif
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/command_messages.h

@@ -1,162 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/defines.h"
-#include "api_message.h"
-
-namespace esphome {
-namespace api {
-
-#ifdef USE_COVER
-enum LegacyCoverCommand {
-  LEGACY_COVER_COMMAND_OPEN = 0,
-  LEGACY_COVER_COMMAND_CLOSE = 1,
-  LEGACY_COVER_COMMAND_STOP = 2,
-};
-
-class CoverCommandRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_key() const;
-  optional<LegacyCoverCommand> get_legacy_command() const;
-  optional<float> get_position() const;
-  optional<float> get_tilt() const;
-  bool get_stop() const { return this->stop_; }
-
- protected:
-  uint32_t key_{0};
-  bool has_legacy_command_{false};
-  LegacyCoverCommand legacy_command_{LEGACY_COVER_COMMAND_OPEN};
-  bool has_position_{false};
-  float position_{0.0f};
-  bool has_tilt_{false};
-  float tilt_{0.0f};
-  bool stop_{false};
-};
-#endif
-
-#ifdef USE_FAN
-class FanCommandRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_key() const;
-  optional<bool> get_state() const;
-  optional<fan::FanSpeed> get_speed() const;
-  optional<bool> get_oscillating() const;
-
- protected:
-  uint32_t key_{0};
-  bool has_state_{false};
-  bool state_{false};
-  bool has_speed_{false};
-  fan::FanSpeed speed_{fan::FAN_SPEED_LOW};
-  bool has_oscillating_{false};
-  bool oscillating_{false};
-};
-#endif
-
-#ifdef USE_LIGHT
-class LightCommandRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_key() const;
-  optional<bool> get_state() const;
-  optional<float> get_brightness() const;
-  optional<float> get_red() const;
-  optional<float> get_green() const;
-  optional<float> get_blue() const;
-  optional<float> get_white() const;
-  optional<float> get_color_temperature() const;
-  optional<uint32_t> get_transition_length() const;
-  optional<uint32_t> get_flash_length() const;
-  optional<std::string> get_effect() const;
-
- protected:
-  uint32_t key_{0};
-  bool has_state_{false};
-  bool state_{false};
-  bool has_brightness_{false};
-  float 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_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_{};
-};
-#endif
-
-#ifdef USE_SWITCH
-class SwitchCommandRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_key() const;
-  bool get_state() const;
-
- protected:
-  uint32_t key_{0};
-  bool state_{false};
-};
-#endif
-
-#ifdef USE_ESP32_CAMERA
-class CameraImageRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool get_single() const;
-  bool get_stream() const;
-  APIMessageType message_type() const override;
-
- protected:
-  bool single_{false};
-  bool stream_{false};
-};
-#endif
-
-#ifdef USE_CLIMATE
-class ClimateCommandRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_key() const;
-  optional<climate::ClimateMode> get_mode() const;
-  optional<float> get_target_temperature() const;
-  optional<float> get_target_temperature_low() const;
-  optional<float> get_target_temperature_high() const;
-  optional<bool> get_away() const;
-
- protected:
-  uint32_t key_{0};
-  bool has_mode_{false};
-  climate::ClimateMode mode_{climate::CLIMATE_MODE_OFF};
-  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_away_{false};
-  bool away_{false};
-};
-#endif
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/custom_api_device.h

@@ -0,0 +1,218 @@
+#pragma once
+
+#include <map>
+#include "user_services.h"
+#include "api_server.h"
+
+namespace esphome {
+namespace api {
+
+template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceBase<Ts...> {
+ public:
+  CustomAPIDeviceService(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names, T *obj,
+                         void (T::*callback)(Ts...))
+      : UserServiceBase<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
+
+ protected:
+  void execute(Ts... x) override { (this->obj_->*this->callback_)(x...); }  // NOLINT
+
+  T *obj_;
+  void (T::*callback_)(Ts...);
+};
+
+class CustomAPIDevice {
+ public:
+  /// Return if a client (such as Home Assistant) is connected to the native API.
+  bool is_connected() const { return global_api_server->is_connected(); }
+
+  /** Register a custom native API service that will show up in Home Assistant.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * void setup() override {
+   *   register_service(&CustomNativeAPI::on_start_washer_cycle, "start_washer_cycle",
+   *                    {"cycle_length"});
+   * }
+   *
+   * void on_start_washer_cycle(int cycle_length) {
+   *   // Start washer cycle.
+   * }
+   * ```
+   *
+   * @tparam T The class type creating the service, automatically deduced from the function pointer.
+   * @tparam Ts The argument types for the service, automatically deduced from the function arguments.
+   * @param callback The member function to call when the service is triggered.
+   * @param name The name of the service to register.
+   * @param arg_names The name of the arguments for the service, must match the arguments of the function.
+   */
+  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);
+    global_api_server->register_user_service(service);
+  }
+
+  /** Register a custom native API service that will show up in Home Assistant.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * void setup() override {
+   *   register_service(&CustomNativeAPI::on_hello_world, "hello_world");
+   * }
+   *
+   * void on_hello_world() {
+   *   // Hello World service called.
+   * }
+   * ```
+   *
+   * @tparam T The class type creating the service, automatically deduced from the function pointer.
+   * @param callback The member function to call when the service is triggered.
+   * @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);
+    global_api_server->register_user_service(service);
+  }
+
+  /** 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, "climate.kitchen", "current_temperature");
+   * }
+   *
+   * void on_state_changed(std::string state) {
+   *   // State of sensor.weather_forecast is `state`
+   * }
+   * ```
+   *
+   * @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,
+                                     const std::string &attribute = "") {
+    auto f = std::bind(callback, (T *) this, std::placeholders::_1);
+    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
+  }
+
+  /** 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");
+   * }
+   *
+   * void on_state_changed(std::string entity_id, std::string state) {
+   *   // State of `entity_id` is `state`
+   * }
+   * ```
+   *
+   * @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,
+                                     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, optional<std::string>(attribute), f);
+  }
+
+  /** Call a Home Assistant service from ESPHome.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * call_homeassistant_service("homeassistant.restart");
+   * ```
+   *
+   * @param service_name The service to call.
+   */
+  void call_homeassistant_service(const std::string &service_name) {
+    HomeassistantServiceResponse resp;
+    resp.service = service_name;
+    global_api_server->send_homeassistant_service_call(resp);
+  }
+
+  /** Call a Home Assistant service from ESPHome.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * call_homeassistant_service("light.turn_on", {
+   *   {"entity_id", "light.my_light"},
+   *   {"brightness", "127"},
+   * });
+   * ```
+   *
+   * @param service_name The service to call.
+   * @param data The data for the service call, mapping from string to string.
+   */
+  void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
+    HomeassistantServiceResponse resp;
+    resp.service = service_name;
+    for (auto &it : data) {
+      HomeassistantServiceMap kv;
+      kv.key = it.first;
+      kv.value = it.second;
+      resp.data.push_back(kv);
+    }
+    global_api_server->send_homeassistant_service_call(resp);
+  }
+
+  /** Fire an ESPHome event in Home Assistant.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * fire_homeassistant_event("esphome.something_happened");
+   * ```
+   *
+   * @param event_name The event to fire.
+   */
+  void fire_homeassistant_event(const std::string &event_name) {
+    HomeassistantServiceResponse resp;
+    resp.service = event_name;
+    resp.is_event = true;
+    global_api_server->send_homeassistant_service_call(resp);
+  }
+
+  /** Fire an ESPHome event in Home Assistant.
+   *
+   * Usage:
+   *
+   * ```cpp
+   * fire_homeassistant_event("esphome.something_happened", {
+   *   {"my_value", "500"},
+   * });
+   * ```
+   *
+   * @param event_name The event to fire.
+   * @param data The data for the event, mapping from string to string.
+   */
+  void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
+    HomeassistantServiceResponse resp;
+    resp.service = service_name;
+    resp.is_event = true;
+    for (auto &it : data) {
+      HomeassistantServiceMap kv;
+      kv.key = it.first;
+      kv.value = it.second;
+      resp.data.push_back(kv);
+    }
+    global_api_server->send_homeassistant_service_call(resp);
+  }
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/homeassistant_service.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/automation.h"
+#include "api_pb2.h"
+#include "api_server.h"
+
+namespace esphome {
+namespace api {
+
+template<typename... Ts> class TemplatableKeyValuePair {
+ public:
+  template<typename T> TemplatableKeyValuePair(std::string key, T value) : key(std::move(key)), value(value) {}
+  std::string key;
+  TemplatableStringValue<Ts...> value;
+};
+
+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 add_data(std::string key, T value) {
+    this->data_.push_back(TemplatableKeyValuePair<Ts...>(key, value));
+  }
+  template<typename T> void add_data_template(std::string key, T value) {
+    this->data_template_.push_back(TemplatableKeyValuePair<Ts...>(key, value));
+  }
+  template<typename T> void add_variable(std::string key, T value) {
+    this->variables_.push_back(TemplatableKeyValuePair<Ts...>(key, value));
+  }
+
+  void play(Ts... x) override {
+    HomeassistantServiceResponse resp;
+    resp.service = this->service_.value(x...);
+    resp.is_event = this->is_event_;
+    for (auto &it : this->data_) {
+      HomeassistantServiceMap kv;
+      kv.key = it.key;
+      kv.value = it.value.value(x...);
+      resp.data.push_back(kv);
+    }
+    for (auto &it : this->data_template_) {
+      HomeassistantServiceMap kv;
+      kv.key = it.key;
+      kv.value = it.value.value(x...);
+      resp.data_template.push_back(kv);
+    }
+    for (auto &it : this->variables_) {
+      HomeassistantServiceMap kv;
+      kv.key = it.key;
+      kv.value = it.value.value(x...);
+      resp.variables.push_back(kv);
+    }
+    this->parent_->send_homeassistant_service_call(resp);
+  }
+
+ protected:
+  APIServer *parent_;
+  bool is_event_;
+  std::vector<TemplatableKeyValuePair<Ts...>> data_;
+  std::vector<TemplatableKeyValuePair<Ts...>> data_template_;
+  std::vector<TemplatableKeyValuePair<Ts...>> variables_;
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/list_entities.cpp

@@ -2,189 +2,54 @@
 #include "esphome/core/util.h"
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
+#include "api_connection.h"
 
 namespace esphome {
 namespace api {
 
-std::string get_default_unique_id(const std::string &component_type, Nameable *nameable) {
-  return App.get_name() + component_type + nameable->get_object_id();
-}
-
 #ifdef USE_BINARY_SENSOR
 bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(binary_sensor);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("binary_sensor", binary_sensor));
-  // string device_class = 5;
-  buffer.encode_string(5, binary_sensor->get_device_class());
-  // bool is_status_binary_sensor = 6;
-  buffer.encode_bool(6, binary_sensor->is_status_binary_sensor());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_BINARY_SENSOR_RESPONSE);
+  return this->client_->send_binary_sensor_info(binary_sensor);
 }
 #endif
 #ifdef USE_COVER
-bool ListEntitiesIterator::on_cover(cover::Cover *cover) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(cover);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("cover", cover));
-  auto traits = cover->get_traits();
-
-  // bool assumed_state = 5;
-  buffer.encode_bool(5, traits.get_is_assumed_state());
-  // bool supports_position = 6;
-  buffer.encode_bool(6, traits.get_supports_position());
-  // bool supports_tilt = 7;
-  buffer.encode_bool(7, traits.get_supports_tilt());
-  // string device_class = 8;
-  buffer.encode_string(8, cover->get_device_class());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_COVER_RESPONSE);
-}
+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) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(fan);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("fan", fan));
-  // bool supports_oscillation = 5;
-  buffer.encode_bool(5, fan->get_traits().supports_oscillation());
-  // bool supports_speed = 6;
-  buffer.encode_bool(6, fan->get_traits().supports_speed());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_FAN_RESPONSE);
-}
+bool ListEntitiesIterator::on_fan(fan::FanState *fan) { return this->client_->send_fan_info(fan); }
 #endif
 #ifdef USE_LIGHT
-bool ListEntitiesIterator::on_light(light::LightState *light) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(light);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("light", light));
-  // bool supports_brightness = 5;
-  auto traits = light->get_traits();
-  buffer.encode_bool(5, traits.get_supports_brightness());
-  // bool supports_rgb = 6;
-  buffer.encode_bool(6, traits.get_supports_rgb());
-  // bool supports_white_value = 7;
-  buffer.encode_bool(7, traits.get_supports_rgb_white_value());
-  // bool supports_color_temperature = 8;
-  buffer.encode_bool(8, traits.get_supports_color_temperature());
-  if (traits.get_supports_color_temperature()) {
-    // float min_mireds = 9;
-    buffer.encode_float(9, traits.get_min_mireds());
-    // float max_mireds = 10;
-    buffer.encode_float(10, traits.get_max_mireds());
-  }
-  // repeated string effects = 11;
-  if (light->supports_effects()) {
-    buffer.encode_string(11, "None");
-    for (auto *effect : light->get_effects()) {
-      buffer.encode_string(11, effect->get_name());
-    }
-  }
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_LIGHT_RESPONSE);
-}
+bool ListEntitiesIterator::on_light(light::LightState *light) { return this->client_->send_light_info(light); }
 #endif
 #ifdef USE_SENSOR
-bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(sensor);
-  // string unique_id = 4;
-  std::string unique_id = sensor->unique_id();
-  if (unique_id.empty())
-    unique_id = get_default_unique_id("sensor", sensor);
-  buffer.encode_string(4, unique_id);
-  // string icon = 5;
-  buffer.encode_string(5, sensor->get_icon());
-  // string unit_of_measurement = 6;
-  buffer.encode_string(6, sensor->get_unit_of_measurement());
-  // int32 accuracy_decimals = 7;
-  buffer.encode_int32(7, sensor->get_accuracy_decimals());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_SENSOR_RESPONSE);
-}
+bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) { return this->client_->send_sensor_info(sensor); }
 #endif
 #ifdef USE_SWITCH
-bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(a_switch);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("switch", a_switch));
-  // string icon = 5;
-  buffer.encode_string(5, a_switch->get_icon());
-  // bool assumed_state = 6;
-  buffer.encode_bool(6, a_switch->assumed_state());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_SWITCH_RESPONSE);
-}
+bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) { return this->client_->send_switch_info(a_switch); }
 #endif
 #ifdef USE_TEXT_SENSOR
 bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(text_sensor);
-  // string unique_id = 4;
-  std::string unique_id = text_sensor->unique_id();
-  if (unique_id.empty())
-    unique_id = get_default_unique_id("text_sensor", text_sensor);
-  buffer.encode_string(4, unique_id);
-  // string icon = 5;
-  buffer.encode_string(5, text_sensor->get_icon());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_TEXT_SENSOR_RESPONSE);
+  return this->client_->send_text_sensor_info(text_sensor);
 }
 #endif
 
-bool ListEntitiesIterator::on_end() {
-  return this->client_->send_empty_message(APIMessageType::LIST_ENTITIES_DONE_RESPONSE);
-}
+bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(); }
 ListEntitiesIterator::ListEntitiesIterator(APIServer *server, APIConnection *client)
     : ComponentIterator(server), client_(client) {}
 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
-  auto buffer = this->client_->get_buffer();
-  service->encode_list_service_response(buffer);
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_SERVICE_RESPONSE);
+  auto resp = service->encode_list_service_response();
+  return this->client_->send_list_entities_services_response(resp);
 }
 
 #ifdef USE_ESP32_CAMERA
 bool ListEntitiesIterator::on_camera(esp32_camera::ESP32Camera *camera) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(camera);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("camera", camera));
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_CAMERA_RESPONSE);
+  return this->client_->send_camera_info(camera);
 }
 #endif
 
 #ifdef USE_CLIMATE
-bool ListEntitiesIterator::on_climate(climate::Climate *climate) {
-  auto buffer = this->client_->get_buffer();
-  buffer.encode_nameable(climate);
-  // string unique_id = 4;
-  buffer.encode_string(4, get_default_unique_id("climate", climate));
-
-  auto traits = climate->get_traits();
-  // bool supports_current_temperature = 5;
-  buffer.encode_bool(5, traits.get_supports_current_temperature());
-  // bool supports_two_point_target_temperature = 6;
-  buffer.encode_bool(6, traits.get_supports_two_point_target_temperature());
-  // repeated ClimateMode supported_modes = 7;
-  for (auto mode : {climate::CLIMATE_MODE_AUTO, climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL,
-                    climate::CLIMATE_MODE_HEAT}) {
-    if (traits.supports_mode(mode))
-      buffer.encode_uint32(7, mode, true);
-  }
-
-  // float visual_min_temperature = 8;
-  buffer.encode_float(8, traits.get_visual_min_temperature());
-  // float visual_max_temperature = 9;
-  buffer.encode_float(9, traits.get_visual_max_temperature());
-  // float visual_temperature_step = 10;
-  buffer.encode_float(10, traits.get_visual_temperature_step());
-  // bool supports_away = 11;
-  buffer.encode_bool(11, traits.get_supports_away());
-  return this->client_->send_buffer(APIMessageType::LIST_ENTITIES_CLIMATE_RESPONSE);
-}
+bool ListEntitiesIterator::on_climate(climate::Climate *climate) { return this->client_->send_climate_info(climate); }
 #endif
 
-APIMessageType ListEntitiesRequest::message_type() const { return APIMessageType::LIST_ENTITIES_REQUEST; }
-
 }  // namespace api
 }  // namespace esphome

esphome/components/api/list_entities.h

@@ -2,16 +2,11 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "api_message.h"
+#include "util.h"
 
 namespace esphome {
 namespace api {
 
-class ListEntitiesRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
 class APIConnection;
 
 class ListEntitiesIterator : public ComponentIterator {

esphome/components/api/proto.cpp

@@ -1,61 +1,59 @@
-#include "api_message.h"
+#include "proto.h"
+#include "util.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.message";
+static const char *TAG = "api.proto";
 
-bool APIMessage::decode_varint(uint32_t field_id, uint32_t value) { return false; }
-bool APIMessage::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) { return false; }
-bool APIMessage::decode_32bit(uint32_t field_id, uint32_t value) { return false; }
-void APIMessage::encode(APIBuffer &buffer) {}
-void APIMessage::decode(const uint8_t *buffer, size_t length) {
+void ProtoMessage::decode(const uint8_t *buffer, size_t length) {
   uint32_t i = 0;
   bool error = false;
   while (i < length) {
     uint32_t consumed;
-    auto res = proto_decode_varuint32(&buffer[i], length - i, &consumed);
+    auto res = ProtoVarInt::parse(&buffer[i], length - i, &consumed);
     if (!res.has_value()) {
       ESP_LOGV(TAG, "Invalid field start at %u", i);
       break;
     }
 
-    uint32_t field_type = (*res) & 0b111;
-    uint32_t field_id = (*res) >> 3;
+    uint32_t field_type = (res->as_uint32()) & 0b111;
+    uint32_t field_id = (res->as_uint32()) >> 3;
     i += consumed;
 
     switch (field_type) {
       case 0: {  // VarInt
-        res = proto_decode_varuint32(&buffer[i], length - i, &consumed);
+        res = ProtoVarInt::parse(&buffer[i], length - i, &consumed);
         if (!res.has_value()) {
           ESP_LOGV(TAG, "Invalid VarInt at %u", i);
           error = true;
           break;
         }
         if (!this->decode_varint(field_id, *res)) {
-          ESP_LOGV(TAG, "Cannot decode VarInt field %u with value %u!", field_id, *res);
+          ESP_LOGV(TAG, "Cannot decode VarInt field %u with value %u!", field_id, res->as_uint32());
         }
         i += consumed;
         break;
       }
       case 2: {  // Length-delimited
-        res = proto_decode_varuint32(&buffer[i], length - i, &consumed);
+        res = ProtoVarInt::parse(&buffer[i], length - i, &consumed);
         if (!res.has_value()) {
           ESP_LOGV(TAG, "Invalid Length Delimited at %u", i);
           error = true;
           break;
         }
+        uint32_t field_length = res->as_uint32();
         i += consumed;
-        if (*res > length - i) {
+        if (field_length > length - i) {
           ESP_LOGV(TAG, "Out-of-bounds Length Delimited at %u", i);
           error = true;
           break;
         }
-        if (!this->decode_length_delimited(field_id, &buffer[i], *res)) {
+        if (!this->decode_length(field_id, ProtoLengthDelimited(&buffer[i], field_length))) {
           ESP_LOGV(TAG, "Cannot decode Length Delimited field %u!", field_id);
         }
-        i += *res;
+        i += field_length;
         break;
       }
       case 5: {  // 32-bit
@@ -64,9 +62,8 @@ void APIMessage::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);
-        if (!this->decode_32bit(field_id, val)) {
+        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);
         }
         i += 4;
@@ -83,5 +80,11 @@ void APIMessage::decode(const uint8_t *buffer, size_t length) {
   }
 }
 
+std::string ProtoMessage::dump() const {
+  std::string out;
+  this->dump_to(out);
+  return out;
+}
+
 }  // namespace api
 }  // namespace esphome

esphome/components/api/proto.h

@@ -0,0 +1,278 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace api {
+
+/// Representation of a VarInt - in ProtoBuf should be 64bit but we only use 32bit
+class ProtoVarInt {
+ public:
+  ProtoVarInt() : value_(0) {}
+  explicit ProtoVarInt(uint64_t value) : value_(value) {}
+
+  static optional<ProtoVarInt> parse(const uint8_t *buffer, uint32_t len, uint32_t *consumed) {
+    if (consumed != nullptr)
+      *consumed = 0;
+
+    if (len == 0)
+      return {};
+
+    uint64_t result = 0;
+    uint8_t bitpos = 0;
+
+    for (uint32_t i = 0; i < len; i++) {
+      uint8_t val = buffer[i];
+      result |= uint64_t(val & 0x7F) << uint64_t(bitpos);
+      bitpos += 7;
+      if ((val & 0x80) == 0) {
+        if (consumed != nullptr)
+          *consumed = i + 1;
+        return ProtoVarInt(result);
+      }
+    }
+
+    return {};
+  }
+
+  uint32_t as_uint32() const { return this->value_; }
+  uint64_t as_uint64() const { return this->value_; }
+  bool as_bool() const { return this->value_; }
+  template<typename T> T as_enum() const { return static_cast<T>(this->as_uint32()); }
+  int32_t as_int32() const {
+    // Not ZigZag encoded
+    return static_cast<int32_t>(this->as_int64());
+  }
+  int64_t as_int64() const {
+    // Not ZigZag encoded
+    return static_cast<int64_t>(this->value_);
+  }
+  int32_t as_sint32() const {
+    // with ZigZag encoding
+    if (this->value_ & 1)
+      return static_cast<int32_t>(~(this->value_ >> 1));
+    else
+      return static_cast<int32_t>(this->value_ >> 1);
+  }
+  int64_t as_sint64() const {
+    // with ZigZag encoding
+    if (this->value_ & 1)
+      return static_cast<int64_t>(~(this->value_ >> 1));
+    else
+      return static_cast<int64_t>(this->value_ >> 1);
+  }
+  void encode(std::vector<uint8_t> &out) {
+    uint32_t val = this->value_;
+    if (val <= 0x7F) {
+      out.push_back(val);
+      return;
+    }
+    while (val) {
+      uint8_t temp = val & 0x7F;
+      val >>= 7;
+      if (val) {
+        out.push_back(temp | 0x80);
+      } else {
+        out.push_back(temp);
+      }
+    }
+  }
+
+ protected:
+  uint64_t value_;
+};
+
+class ProtoLengthDelimited {
+ public:
+  explicit ProtoLengthDelimited(const uint8_t *value, size_t length) : value_(value), length_(length) {}
+  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->value_), this->length_); }
+  template<class C> C as_message() const {
+    auto msg = C();
+    msg.decode(this->value_, this->length_);
+    return msg;
+  }
+
+ protected:
+  const uint8_t *const value_;
+  const size_t length_;
+};
+
+class Proto32Bit {
+ public:
+  explicit Proto32Bit(uint32_t value) : value_(value) {}
+  uint32_t as_fixed32() const { return this->value_; }
+  int32_t as_sfixed32() const { return static_cast<int32_t>(this->value_); }
+  float as_float() const {
+    union {
+      uint32_t raw;
+      float value;
+    } s{};
+    s.raw = this->value_;
+    return s.value;
+  }
+
+ protected:
+  const uint32_t value_;
+};
+
+class Proto64Bit {
+ public:
+  explicit Proto64Bit(uint64_t value) : value_(value) {}
+  uint64_t as_fixed64() const { return this->value_; }
+  int64_t as_sfixed64() const { return static_cast<int64_t>(this->value_); }
+  double as_double() const {
+    union {
+      uint64_t raw;
+      double value;
+    } s{};
+    s.raw = this->value_;
+    return s.value;
+  }
+
+ protected:
+  const uint64_t value_;
+};
+
+class ProtoWriteBuffer {
+ public:
+  ProtoWriteBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
+  void write(uint8_t value) { this->buffer_->push_back(value); }
+  void encode_varint_raw(ProtoVarInt value) { value.encode(*this->buffer_); }
+  void encode_varint_raw(uint32_t value) { this->encode_varint_raw(ProtoVarInt(value)); }
+  void encode_field_raw(uint32_t field_id, uint32_t type) {
+    uint32_t val = (field_id << 3) | (type & 0b111);
+    this->encode_varint_raw(val);
+  }
+  void encode_string(uint32_t field_id, const char *string, size_t len, bool force = false) {
+    if (len == 0 && !force)
+      return;
+
+    this->encode_field_raw(field_id, 2);
+    this->encode_varint_raw(len);
+    auto *data = reinterpret_cast<const uint8_t *>(string);
+    for (size_t i = 0; i < len; i++)
+      this->write(data[i]);
+  }
+  void encode_string(uint32_t field_id, const std::string &value, bool force = false) {
+    this->encode_string(field_id, value.data(), value.size());
+  }
+  void encode_bytes(uint32_t field_id, const uint8_t *data, size_t len, bool force = false) {
+    this->encode_string(field_id, reinterpret_cast<const char *>(data), len, force);
+  }
+  void encode_uint32(uint32_t field_id, uint32_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    this->encode_field_raw(field_id, 0);
+    this->encode_varint_raw(value);
+  }
+  void encode_uint64(uint32_t field_id, uint64_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    this->encode_field_raw(field_id, 0);
+    this->encode_varint_raw(ProtoVarInt(value));
+  }
+  void encode_bool(uint32_t field_id, bool value, bool force = false) {
+    if (!value && !force)
+      return;
+    this->encode_field_raw(field_id, 0);
+    this->write(0x01);
+  }
+  void encode_fixed32(uint32_t field_id, uint32_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);
+  }
+  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);
+  }
+  void encode_float(uint32_t field_id, float value, bool force = false) {
+    if (value == 0.0f && !force)
+      return;
+
+    union {
+      float value;
+      uint32_t raw;
+    } val{};
+    val.value = value;
+    this->encode_fixed32(field_id, val.raw);
+  }
+  void encode_int32(uint32_t field_id, int32_t value, bool force = false) {
+    if (value < 0) {
+      // negative int32 is always 10 byte long
+      this->encode_int64(field_id, value, force);
+      return;
+    }
+    this->encode_uint32(field_id, static_cast<uint32_t>(value), force);
+  }
+  void encode_int64(uint32_t field_id, int64_t value, bool force = false) {
+    this->encode_uint64(field_id, static_cast<uint64_t>(value), force);
+  }
+  void encode_sint32(uint32_t field_id, int32_t value, bool force = false) {
+    uint32_t uvalue;
+    if (value < 0)
+      uvalue = ~(value << 1);
+    else
+      uvalue = value << 1;
+    this->encode_uint32(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();
+
+    value.encode(*this);
+
+    const uint32_t nested_length = this->buffer_->size() - begin;
+    // add size varint
+    std::vector<uint8_t> var;
+    ProtoVarInt(nested_length).encode(var);
+    this->buffer_->insert(this->buffer_->begin() + begin, var.begin(), var.end());
+  }
+  std::vector<uint8_t> *get_buffer() const { return buffer_; }
+
+ protected:
+  std::vector<uint8_t> *buffer_;
+};
+
+class ProtoMessage {
+ public:
+  virtual void encode(ProtoWriteBuffer buffer) const = 0;
+  void decode(const uint8_t *buffer, size_t length);
+  std::string dump() const;
+  virtual void dump_to(std::string &out) const = 0;
+
+ protected:
+  virtual bool decode_varint(uint32_t field_id, ProtoVarInt value) { return false; }
+  virtual bool decode_length(uint32_t field_id, ProtoLengthDelimited value) { return false; }
+  virtual bool decode_32bit(uint32_t field_id, Proto32Bit value) { return false; }
+  virtual bool decode_64bit(uint32_t field_id, Proto64Bit value) { return false; }
+};
+
+template<typename T> const char *proto_enum_to_string(T value);
+
+class ProtoService {
+ public:
+ protected:
+  virtual bool is_authenticated() = 0;
+  virtual bool is_connection_setup() = 0;
+  virtual void on_fatal_error() = 0;
+  virtual void on_unauthenticated_access() = 0;
+  virtual void on_no_setup_connection() = 0;
+  virtual ProtoWriteBuffer create_buffer() = 0;
+  virtual bool send_buffer(ProtoWriteBuffer buffer, uint32_t message_type) = 0;
+  virtual bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) = 0;
+
+  template<class C> bool send_message_(const C &msg, uint32_t message_type) {
+    auto buffer = this->create_buffer();
+    msg.encode(buffer);
+    return this->send_buffer(buffer, message_type);
+  }
+};
+
+}  // namespace api
+}  // namespace esphome

esphome/components/api/service_call_message.cpp

@@ -1,49 +0,0 @@
-#include "service_call_message.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace api {
-
-APIMessageType SubscribeServiceCallsRequest::message_type() const {
-  return APIMessageType::SUBSCRIBE_SERVICE_CALLS_REQUEST;
-}
-
-APIMessageType ServiceCallResponse::message_type() const { return APIMessageType::SERVICE_CALL_RESPONSE; }
-void ServiceCallResponse::encode(APIBuffer &buffer) {
-  // string service = 1;
-  buffer.encode_string(1, this->service_);
-  // map<string, string> data = 2;
-  for (auto &it : this->data_) {
-    auto nested = buffer.begin_nested(2);
-    buffer.encode_string(1, it.key);
-    buffer.encode_string(2, it.value);
-    buffer.end_nested(nested);
-  }
-  // map<string, string> data_template = 3;
-  for (auto &it : this->data_template_) {
-    auto nested = buffer.begin_nested(3);
-    buffer.encode_string(1, it.key);
-    buffer.encode_string(2, it.value);
-    buffer.end_nested(nested);
-  }
-  // map<string, string> variables = 4;
-  for (auto &it : this->variables_) {
-    auto nested = buffer.begin_nested(4);
-    buffer.encode_string(1, it.key);
-    buffer.encode_string(2, it.value());
-    buffer.end_nested(nested);
-  }
-}
-void ServiceCallResponse::set_service(const std::string &service) { this->service_ = service; }
-void ServiceCallResponse::set_data(const std::vector<KeyValuePair> &data) { this->data_ = data; }
-void ServiceCallResponse::set_data_template(const std::vector<KeyValuePair> &data_template) {
-  this->data_template_ = data_template;
-}
-void ServiceCallResponse::set_variables(const std::vector<TemplatableKeyValuePair> &variables) {
-  this->variables_ = variables;
-}
-
-KeyValuePair::KeyValuePair(const std::string &key, const std::string &value) : key(key), value(value) {}
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/service_call_message.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/automation.h"
-#include "api_message.h"
-
-namespace esphome {
-namespace api {
-
-class SubscribeServiceCallsRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-class KeyValuePair {
- public:
-  KeyValuePair(const std::string &key, const std::string &value);
-
-  std::string key;
-  std::string value;
-};
-
-class TemplatableKeyValuePair {
- public:
-  template<typename T> TemplatableKeyValuePair(std::string key, T func);
-
-  std::string key;
-  std::function<std::string()> value;
-};
-template<typename T> TemplatableKeyValuePair::TemplatableKeyValuePair(std::string key, T func) : key(key) {
-  this->value = [func]() -> std::string { return to_string(func()); };
-}
-
-class ServiceCallResponse : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-
-  void encode(APIBuffer &buffer) override;
-
-  void set_service(const std::string &service);
-  void set_data(const std::vector<KeyValuePair> &data);
-  void set_data_template(const std::vector<KeyValuePair> &data_template);
-  void set_variables(const std::vector<TemplatableKeyValuePair> &variables);
-
- protected:
-  std::string service_;
-  std::vector<KeyValuePair> data_;
-  std::vector<KeyValuePair> data_template_;
-  std::vector<TemplatableKeyValuePair> variables_;
-};
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/subscribe_logs.cpp

@@ -1,26 +0,0 @@
-#include "subscribe_logs.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace api {
-
-APIMessageType SubscribeLogsRequest::message_type() const { return APIMessageType::SUBSCRIBE_LOGS_REQUEST; }
-bool SubscribeLogsRequest::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:  // LogLevel level = 1;
-      this->level_ = value;
-      return true;
-    case 2:  // bool dump_config = 2;
-      this->dump_config_ = value;
-      return true;
-    default:
-      return false;
-  }
-}
-uint32_t SubscribeLogsRequest::get_level() const { return this->level_; }
-void SubscribeLogsRequest::set_level(uint32_t level) { this->level_ = level; }
-bool SubscribeLogsRequest::get_dump_config() const { return this->dump_config_; }
-void SubscribeLogsRequest::set_dump_config(bool dump_config) { this->dump_config_ = dump_config; }
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/subscribe_logs.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "api_message.h"
-
-namespace esphome {
-namespace api {
-
-class SubscribeLogsRequest : public APIMessage {
- public:
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-  uint32_t get_level() const;
-  void set_level(uint32_t level);
-  bool get_dump_config() const;
-  void set_dump_config(bool dump_config);
-
- protected:
-  uint32_t level_{6};
-  bool dump_config_{false};
-};
-
-}  // namespace api
-}  // namespace esphome

esphome/components/api/subscribe_state.cpp

@@ -1,4 +1,5 @@
 #include "subscribe_state.h"
+#include "api_connection.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -6,9 +7,6 @@ namespace api {
 
 #ifdef USE_BINARY_SENSOR
 bool InitialStateIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) {
-  if (!binary_sensor->has_state())
-    return true;
-
   return this->client_->send_binary_sensor_state(binary_sensor, binary_sensor->state);
 }
 #endif
@@ -23,9 +21,6 @@ bool InitialStateIterator::on_light(light::LightState *light) { return this->cli
 #endif
 #ifdef USE_SENSOR
 bool InitialStateIterator::on_sensor(sensor::Sensor *sensor) {
-  if (!sensor->has_state())
-    return true;
-
   return this->client_->send_sensor_state(sensor, sensor->state);
 }
 #endif
@@ -36,9 +31,6 @@ bool InitialStateIterator::on_switch(switch_::Switch *a_switch) {
 #endif
 #ifdef USE_TEXT_SENSOR
 bool InitialStateIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
-  if (!text_sensor->has_state())
-    return true;
-
   return this->client_->send_text_sensor_state(text_sensor, text_sensor->state);
 }
 #endif
@@ -48,30 +40,5 @@ bool InitialStateIterator::on_climate(climate::Climate *climate) { return this->
 InitialStateIterator::InitialStateIterator(APIServer *server, APIConnection *client)
     : ComponentIterator(server), client_(client) {}
 
-APIMessageType SubscribeStatesRequest::message_type() const { return APIMessageType::SUBSCRIBE_STATES_REQUEST; }
-
-bool HomeAssistantStateResponse::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 1:
-      // string entity_id = 1;
-      this->entity_id_ = as_string(value, len);
-      return true;
-    case 2:
-      // string state = 2;
-      this->state_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
-}
-APIMessageType HomeAssistantStateResponse::message_type() const {
-  return APIMessageType::HOME_ASSISTANT_STATE_RESPONSE;
-}
-const std::string &HomeAssistantStateResponse::get_entity_id() const { return this->entity_id_; }
-const std::string &HomeAssistantStateResponse::get_state() const { return this->state_; }
-APIMessageType SubscribeHomeAssistantStatesRequest::message_type() const {
-  return APIMessageType::SUBSCRIBE_HOME_ASSISTANT_STATES_REQUEST;
-}
-
 }  // namespace api
 }  // namespace esphome

esphome/components/api/subscribe_state.h

@@ -4,16 +4,10 @@
 #include "esphome/core/controller.h"
 #include "esphome/core/defines.h"
 #include "util.h"
-#include "api_message.h"
 
 namespace esphome {
 namespace api {
 
-class SubscribeStatesRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
 class APIConnection;
 
 class InitialStateIterator : public ComponentIterator {
@@ -47,23 +41,6 @@ class InitialStateIterator : public ComponentIterator {
   APIConnection *client_;
 };
 
-class SubscribeHomeAssistantStatesRequest : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-};
-
-class HomeAssistantStateResponse : public APIMessage {
- public:
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  APIMessageType message_type() const override;
-  const std::string &get_entity_id() const;
-  const std::string &get_state() const;
-
- protected:
-  std::string entity_id_;
-  std::string state_;
-};
-
 }  // namespace api
 }  // namespace esphome
 

esphome/components/api/user_services.cpp

@@ -4,71 +4,39 @@
 namespace esphome {
 namespace api {
 
-template<> bool ExecuteServiceArgument::get_value<bool>() { return this->value_bool_; }
-template<> int ExecuteServiceArgument::get_value<int>() { return this->value_int_; }
-template<> float ExecuteServiceArgument::get_value<float>() { return this->value_float_; }
-template<> std::string ExecuteServiceArgument::get_value<std::string>() { return this->value_string_; }
-
-APIMessageType ExecuteServiceArgument::message_type() const { return APIMessageType::EXECUTE_SERVICE_REQUEST; }
-bool ExecuteServiceArgument::decode_varint(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:  // bool bool_ = 1;
-      this->value_bool_ = value;
-      return true;
-    case 2:  // int32 int_ = 2;
-      this->value_int_ = value;
-      return true;
-    default:
-      return false;
-  }
+template<> bool get_execute_arg_value<bool>(const ExecuteServiceArgument &arg) { return arg.bool_; }
+template<> int get_execute_arg_value<int>(const ExecuteServiceArgument &arg) {
+  if (arg.legacy_int != 0)
+    return arg.legacy_int;
+  return arg.int_;
 }
-bool ExecuteServiceArgument::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 3:  // float float_ = 3;
-      this->value_float_ = as_float(value);
-      return true;
-    default:
-      return false;
-  }
+template<> float get_execute_arg_value<float>(const ExecuteServiceArgument &arg) { return arg.float_; }
+template<> std::string get_execute_arg_value<std::string>(const ExecuteServiceArgument &arg) { return arg.string_; }
+template<> std::vector<bool> get_execute_arg_value<std::vector<bool>>(const ExecuteServiceArgument &arg) {
+  return arg.bool_array;
 }
-bool ExecuteServiceArgument::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 4:  // string string_ = 4;
-      this->value_string_ = as_string(value, len);
-      return true;
-    default:
-      return false;
-  }
+template<> std::vector<int> get_execute_arg_value<std::vector<int>>(const ExecuteServiceArgument &arg) {
+  return arg.int_array;
+}
+template<> std::vector<float> get_execute_arg_value<std::vector<float>>(const ExecuteServiceArgument &arg) {
+  return arg.float_array;
+}
+template<> std::vector<std::string> get_execute_arg_value<std::vector<std::string>>(const ExecuteServiceArgument &arg) {
+  return arg.string_array;
 }
 
-bool ExecuteServiceRequest::decode_32bit(uint32_t field_id, uint32_t value) {
-  switch (field_id) {
-    case 1:  // fixed32 key = 1;
-      this->key_ = value;
-      return true;
-    default:
-      return false;
-  }
+template<> enums::ServiceArgType to_service_arg_type<bool>() { return enums::SERVICE_ARG_TYPE_BOOL; }
+template<> enums::ServiceArgType to_service_arg_type<int>() { return enums::SERVICE_ARG_TYPE_INT; }
+template<> enums::ServiceArgType to_service_arg_type<float>() { return enums::SERVICE_ARG_TYPE_FLOAT; }
+template<> enums::ServiceArgType to_service_arg_type<std::string>() { return enums::SERVICE_ARG_TYPE_STRING; }
+template<> enums::ServiceArgType to_service_arg_type<std::vector<bool>>() { return enums::SERVICE_ARG_TYPE_BOOL_ARRAY; }
+template<> enums::ServiceArgType to_service_arg_type<std::vector<int>>() { return enums::SERVICE_ARG_TYPE_INT_ARRAY; }
+template<> enums::ServiceArgType to_service_arg_type<std::vector<float>>() {
+  return enums::SERVICE_ARG_TYPE_FLOAT_ARRAY;
 }
-bool ExecuteServiceRequest::decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) {
-  switch (field_id) {
-    case 2: {  // repeated ExecuteServiceArgument args = 2;
-      ExecuteServiceArgument arg;
-      arg.decode(value, len);
-      this->args_.push_back(arg);
-      return true;
-    }
-    default:
-      return false;
-  }
+template<> enums::ServiceArgType to_service_arg_type<std::vector<std::string>>() {
+  return enums::SERVICE_ARG_TYPE_STRING_ARRAY;
 }
-APIMessageType ExecuteServiceRequest::message_type() const { return APIMessageType::EXECUTE_SERVICE_REQUEST; }
-const std::vector<ExecuteServiceArgument> &ExecuteServiceRequest::get_args() const { return this->args_; }
-uint32_t ExecuteServiceRequest::get_key() const { return this->key_; }
-
-ServiceTypeArgument::ServiceTypeArgument(const std::string &name, ServiceArgType type) : name_(name), type_(type) {}
-const std::string &ServiceTypeArgument::get_name() const { return this->name_; }
-ServiceArgType ServiceTypeArgument::get_type() const { return this->type_; }
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/user_services.h

@@ -2,124 +2,71 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"
-#include "api_message.h"
+#include "api_pb2.h"
 
 namespace esphome {
 namespace api {
 
-enum ServiceArgType {
-  SERVICE_ARG_TYPE_BOOL = 0,
-  SERVICE_ARG_TYPE_INT = 1,
-  SERVICE_ARG_TYPE_FLOAT = 2,
-  SERVICE_ARG_TYPE_STRING = 3,
-};
-
-class ServiceTypeArgument {
- public:
-  ServiceTypeArgument(const std::string &name, ServiceArgType type);
-  const std::string &get_name() const;
-  ServiceArgType get_type() const;
-
- protected:
-  std::string name_;
-  ServiceArgType type_;
-};
-
-class ExecuteServiceArgument : public APIMessage {
- public:
-  APIMessageType message_type() const override;
-  template<typename T> T get_value();
-
-  bool decode_varint(uint32_t field_id, uint32_t value) override;
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-
- protected:
-  bool value_bool_{false};
-  int value_int_{0};
-  float value_float_{0.0f};
-  std::string value_string_{};
-};
-
-class ExecuteServiceRequest : public APIMessage {
- public:
-  bool decode_length_delimited(uint32_t field_id, const uint8_t *value, size_t len) override;
-  bool decode_32bit(uint32_t field_id, uint32_t value) override;
-  APIMessageType message_type() const override;
-
-  uint32_t get_key() const;
-  const std::vector<ExecuteServiceArgument> &get_args() const;
-
- protected:
-  uint32_t key_;
-  std::vector<ExecuteServiceArgument> args_;
-};
-
 class UserServiceDescriptor {
  public:
-  virtual void encode_list_service_response(APIBuffer &buffer) = 0;
+  virtual ListEntitiesServicesResponse encode_list_service_response() = 0;
 
   virtual bool execute_service(const ExecuteServiceRequest &req) = 0;
 };
 
-template<typename... Ts> class UserService : public UserServiceDescriptor, public Trigger<Ts...> {
+template<typename T> T get_execute_arg_value(const ExecuteServiceArgument &arg);
+
+template<typename T> enums::ServiceArgType to_service_arg_type();
+
+template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
  public:
-  UserService(const std::string &name, const std::array<ServiceTypeArgument, sizeof...(Ts)> &args);
+  UserServiceBase(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+      : name_(name), arg_names_(arg_names) {
+    this->key_ = fnv1_hash(this->name_);
+  }
 
-  void encode_list_service_response(APIBuffer &buffer) override;
+  ListEntitiesServicesResponse encode_list_service_response() override {
+    ListEntitiesServicesResponse msg;
+    msg.name = this->name_;
+    msg.key = this->key_;
+    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
+    for (int i = 0; i < sizeof...(Ts); i++) {
+      ListEntitiesServicesArgument arg;
+      arg.type = arg_types[i];
+      arg.name = this->arg_names_[i];
+      msg.args.push_back(arg);
+    }
+    return msg;
+  }
 
-  bool execute_service(const ExecuteServiceRequest &req) override;
+  bool execute_service(const ExecuteServiceRequest &req) override {
+    if (req.key != this->key_)
+      return false;
+    if (req.args.size() != this->arg_names_.size())
+      return false;
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
+    return true;
+  }
 
  protected:
-  template<int... S> void execute_(std::vector<ExecuteServiceArgument> args, seq<S...>);
+  virtual void execute(Ts... x) = 0;
+  template<int... S> void execute_(std::vector<ExecuteServiceArgument> args, seq<S...>) {
+    this->execute((get_execute_arg_value<Ts>(args[S]))...);
+  }
 
   std::string name_;
   uint32_t key_{0};
-  std::array<ServiceTypeArgument, sizeof...(Ts)> args_;
+  std::array<std::string, sizeof...(Ts)> arg_names_;
 };
 
-template<typename... Ts>
-template<int... S>
-void UserService<Ts...>::execute_(std::vector<ExecuteServiceArgument> args, seq<S...>) {
-  this->trigger((args[S].get_value<Ts>())...);
-}
-template<typename... Ts> void UserService<Ts...>::encode_list_service_response(APIBuffer &buffer) {
-  // string name = 1;
-  buffer.encode_string(1, this->name_);
-  // fixed32 key = 2;
-  buffer.encode_fixed32(2, this->key_);
+template<typename... Ts> class UserServiceTrigger : public UserServiceBase<Ts...>, public Trigger<Ts...> {
+ public:
+  UserServiceTrigger(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names)
+      : UserServiceBase<Ts...>(name, arg_names) {}
 
-  // repeated ListServicesArgument args = 3;
-  for (auto &arg : this->args_) {
-    auto nested = buffer.begin_nested(3);
-    // string name = 1;
-    buffer.encode_string(1, arg.get_name());
-    // Type type = 2;
-    buffer.encode_int32(2, arg.get_type());
-    buffer.end_nested(nested);
-  }
-}
-template<typename... Ts> bool UserService<Ts...>::execute_service(const ExecuteServiceRequest &req) {
-  if (req.get_key() != this->key_)
-    return false;
-
-  if (req.get_args().size() != this->args_.size()) {
-    return false;
-  }
-
-  this->execute_(req.get_args(), typename gens<sizeof...(Ts)>::type());
-  return true;
-}
-template<typename... Ts>
-UserService<Ts...>::UserService(const std::string &name, const std::array<ServiceTypeArgument, sizeof...(Ts)> &args)
-    : name_(name), args_(args) {
-  this->key_ = fnv1_hash(this->name_);
-}
-
-template<> bool ExecuteServiceArgument::get_value<bool>();
-template<> int ExecuteServiceArgument::get_value<int>();
-template<> float ExecuteServiceArgument::get_value<float>();
-template<> std::string ExecuteServiceArgument::get_value<std::string>();
+ protected:
+  void execute(Ts... x) override { this->trigger(x...); }  // NOLINT
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/util.cpp

@@ -7,166 +7,6 @@
 namespace esphome {
 namespace api {
 
-APIBuffer::APIBuffer(std::vector<uint8_t> *buffer) : buffer_(buffer) {}
-size_t APIBuffer::get_length() const { return this->buffer_->size(); }
-void APIBuffer::write(uint8_t value) { this->buffer_->push_back(value); }
-void APIBuffer::encode_uint32(uint32_t field, uint32_t value, bool force) {
-  if (value == 0 && !force)
-    return;
-
-  this->encode_field_raw(field, 0);
-  this->encode_varint_raw(value);
-}
-void APIBuffer::encode_int32(uint32_t field, int32_t value, bool force) {
-  this->encode_uint32(field, static_cast<uint32_t>(value), force);
-}
-void APIBuffer::encode_bool(uint32_t field, bool value, bool force) {
-  if (!value && !force)
-    return;
-
-  this->encode_field_raw(field, 0);
-  this->write(0x01);
-}
-void APIBuffer::encode_string(uint32_t field, const std::string &value) {
-  this->encode_string(field, value.data(), value.size());
-}
-void APIBuffer::encode_bytes(uint32_t field, const uint8_t *data, size_t len) {
-  this->encode_string(field, reinterpret_cast<const char *>(data), len);
-}
-void APIBuffer::encode_string(uint32_t field, const char *string, size_t len) {
-  if (len == 0)
-    return;
-
-  this->encode_field_raw(field, 2);
-  this->encode_varint_raw(len);
-  const uint8_t *data = reinterpret_cast<const uint8_t *>(string);
-  for (size_t i = 0; i < len; i++) {
-    this->write(data[i]);
-  }
-}
-void APIBuffer::encode_fixed32(uint32_t field, uint32_t value, bool force) {
-  if (value == 0 && !force)
-    return;
-
-  this->encode_field_raw(field, 5);
-  this->write((value >> 0) & 0xFF);
-  this->write((value >> 8) & 0xFF);
-  this->write((value >> 16) & 0xFF);
-  this->write((value >> 24) & 0xFF);
-}
-void APIBuffer::encode_float(uint32_t field, float value, bool force) {
-  if (value == 0.0f && !force)
-    return;
-
-  union {
-    float value_f;
-    uint32_t value_raw;
-  } val;
-  val.value_f = value;
-  this->encode_fixed32(field, val.value_raw);
-}
-void APIBuffer::encode_field_raw(uint32_t field, uint32_t type) {
-  uint32_t val = (field << 3) | (type & 0b111);
-  this->encode_varint_raw(val);
-}
-void APIBuffer::encode_varint_raw(uint32_t value) {
-  if (value <= 0x7F) {
-    this->write(value);
-    return;
-  }
-
-  while (value) {
-    uint8_t temp = value & 0x7F;
-    value >>= 7;
-    if (value) {
-      this->write(temp | 0x80);
-    } else {
-      this->write(temp);
-    }
-  }
-}
-void APIBuffer::encode_sint32(uint32_t field, int32_t value, bool force) {
-  if (value < 0)
-    this->encode_uint32(field, ~(uint32_t(value) << 1), force);
-  else
-    this->encode_uint32(field, uint32_t(value) << 1, force);
-}
-void APIBuffer::encode_nameable(Nameable *nameable) {
-  // string object_id = 1;
-  this->encode_string(1, nameable->get_object_id());
-  // fixed32 key = 2;
-  this->encode_fixed32(2, nameable->get_object_id_hash());
-  // string name = 3;
-  this->encode_string(3, nameable->get_name());
-}
-size_t APIBuffer::begin_nested(uint32_t field) {
-  this->encode_field_raw(field, 2);
-  return this->buffer_->size();
-}
-void APIBuffer::end_nested(size_t begin_index) {
-  const uint32_t nested_length = this->buffer_->size() - begin_index;
-  // add varint
-  std::vector<uint8_t> var;
-  uint32_t val = nested_length;
-  if (val <= 0x7F) {
-    var.push_back(val);
-  } else {
-    while (val) {
-      uint8_t temp = val & 0x7F;
-      val >>= 7;
-      if (val) {
-        var.push_back(temp | 0x80);
-      } else {
-        var.push_back(temp);
-      }
-    }
-  }
-  this->buffer_->insert(this->buffer_->begin() + begin_index, var.begin(), var.end());
-}
-
-optional<uint32_t> proto_decode_varuint32(const uint8_t *buf, size_t len, uint32_t *consumed) {
-  if (len == 0)
-    return {};
-
-  uint32_t result = 0;
-  uint8_t bitpos = 0;
-
-  for (uint32_t i = 0; i < len; i++) {
-    uint8_t val = buf[i];
-    result |= uint32_t(val & 0x7F) << bitpos;
-    bitpos += 7;
-    if ((val & 0x80) == 0) {
-      if (consumed != nullptr) {
-        *consumed = i + 1;
-      }
-      return result;
-    }
-  }
-
-  return {};
-}
-
-std::string as_string(const uint8_t *value, size_t len) {
-  return std::string(reinterpret_cast<const char *>(value), len);
-}
-
-int32_t as_sint32(uint32_t val) {
-  if (val & 1)
-    return uint32_t(~(val >> 1));
-  else
-    return uint32_t(val >> 1);
-}
-
-float as_float(uint32_t val) {
-  static_assert(sizeof(uint32_t) == sizeof(float), "float must be 32bit long");
-  union {
-    uint32_t raw;
-    float value;
-  } x;
-  x.raw = val;
-  return x.value;
-}
-
 ComponentIterator::ComponentIterator(APIServer *server) : server_(server) {}
 void ComponentIterator::begin() {
   this->state_ = IteratorState::BEGIN;

esphome/components/api/util.h

@@ -10,40 +10,6 @@
 namespace esphome {
 namespace api {
 
-class APIBuffer {
- public:
-  APIBuffer(std::vector<uint8_t> *buffer);
-
-  size_t get_length() const;
-  void write(uint8_t value);
-
-  void encode_int32(uint32_t field, int32_t value, bool force = false);
-  void encode_uint32(uint32_t field, uint32_t value, bool force = false);
-  void encode_sint32(uint32_t field, int32_t value, bool force = false);
-  void encode_bool(uint32_t field, bool value, bool force = false);
-  void encode_string(uint32_t field, const std::string &value);
-  void encode_string(uint32_t field, const char *string, size_t len);
-  void encode_bytes(uint32_t field, const uint8_t *data, size_t len);
-  void encode_fixed32(uint32_t field, uint32_t value, bool force = false);
-  void encode_float(uint32_t field, float value, bool force = false);
-  void encode_nameable(Nameable *nameable);
-
-  size_t begin_nested(uint32_t field);
-  void end_nested(size_t begin_index);
-
-  void encode_field_raw(uint32_t field, uint32_t type);
-  void encode_varint_raw(uint32_t value);
-
- protected:
-  std::vector<uint8_t> *buffer_;
-};
-
-optional<uint32_t> proto_decode_varuint32(const uint8_t *buf, size_t len, uint32_t *consumed = nullptr);
-
-std::string as_string(const uint8_t *value, size_t len);
-int32_t as_sint32(uint32_t val);
-float as_float(uint32_t val);
-
 class APIServer;
 class UserServiceDescriptor;
 

esphome/components/as3935/__init__.py

@@ -0,0 +1,54 @@
+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,
+)
+
+AUTO_LOAD = ["sensor", "binary_sensor"]
+MULTI_CONF = True
+
+CONF_AS3935_ID = "as3935_id"
+
+as3935_ns = cg.esphome_ns.namespace("as3935")
+AS3935 = as3935_ns.class_("AS3935Component", cg.Component)
+
+CONF_IRQ_PIN = "irq_pin"
+AS3935_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(AS3935),
+        cv.Required(CONF_IRQ_PIN): pins.gpio_input_pin_schema,
+        cv.Optional(CONF_INDOOR, default=True): cv.boolean,
+        cv.Optional(CONF_NOISE_LEVEL, default=2): cv.int_range(min=1, max=7),
+        cv.Optional(CONF_WATCHDOG_THRESHOLD, default=2): cv.int_range(min=1, max=10),
+        cv.Optional(CONF_SPIKE_REJECTION, default=2): cv.int_range(min=1, max=11),
+        cv.Optional(CONF_LIGHTNING_THRESHOLD, default=1): cv.one_of(
+            1, 5, 9, 16, int=True
+        ),
+        cv.Optional(CONF_MASK_DISTURBER, default=False): cv.boolean,
+        cv.Optional(CONF_DIV_RATIO, default=0): cv.one_of(0, 16, 32, 64, 128, int=True),
+        cv.Optional(CONF_CAPACITANCE, default=0): cv.int_range(min=0, max=15),
+    }
+)
+
+
+async def setup_as3935(var, config):
+    await cg.register_component(var, config)
+
+    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]))
+    cg.add(var.set_watchdog_threshold(config[CONF_WATCHDOG_THRESHOLD]))
+    cg.add(var.set_spike_rejection(config[CONF_SPIKE_REJECTION]))
+    cg.add(var.set_lightning_threshold(config[CONF_LIGHTNING_THRESHOLD]))
+    cg.add(var.set_mask_disturber(config[CONF_MASK_DISTURBER]))
+    cg.add(var.set_div_ratio(config[CONF_DIV_RATIO]))
+    cg.add(var.set_capacitance(config[CONF_CAPACITANCE]))

esphome/components/as3935/as3935.cpp

@@ -0,0 +1,226 @@
+#include "as3935.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace as3935 {
+
+static const char *TAG = "as3935";
+
+void AS3935Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up AS3935...");
+
+  this->irq_pin_->setup();
+  LOG_PIN("  IRQ Pin: ", this->irq_pin_);
+
+  // Write properties to sensor
+  this->write_indoor(this->indoor_);
+  this->write_noise_level(this->noise_level_);
+  this->write_watchdog_threshold(this->watchdog_threshold_);
+  this->write_spike_rejection(this->spike_rejection_);
+  this->write_lightning_threshold(this->lightning_threshold_);
+  this->write_mask_disturber(this->mask_disturber_);
+  this->write_div_ratio(this->div_ratio_);
+  this->write_capacitance(this->capacitance_);
+}
+
+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; }
+
+void AS3935Component::loop() {
+  if (!this->irq_pin_->digital_read())
+    return;
+
+  uint8_t int_value = this->read_interrupt_register_();
+  if (int_value == NOISE_INT) {
+    ESP_LOGI(TAG, "Noise was detected - try increasing the noise level value!");
+  } else if (int_value == DISTURBER_INT) {
+    ESP_LOGI(TAG, "Disturber was detected - try increasing the spike rejection value!");
+  } else if (int_value == LIGHTNING_INT) {
+    ESP_LOGI(TAG, "Lightning has been detected!");
+    if (this->thunder_alert_binary_sensor_ != nullptr)
+      this->thunder_alert_binary_sensor_->publish_state(true);
+    uint8_t distance = this->get_distance_to_storm_();
+    if (this->distance_sensor_ != nullptr)
+      this->distance_sensor_->publish_state(distance);
+    uint32_t energy = this->get_lightning_energy_();
+    if (this->energy_sensor_ != nullptr)
+      this->energy_sensor_->publish_state(energy);
+  }
+  this->thunder_alert_binary_sensor_->publish_state(false);
+}
+
+void AS3935Component::write_indoor(bool indoor) {
+  ESP_LOGV(TAG, "Setting indoor to %d", indoor);
+  if (indoor)
+    this->write_register(AFE_GAIN, GAIN_MASK, INDOOR, 1);
+  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
+// IRQ Pin.
+void AS3935Component::write_watchdog_threshold(uint8_t watchdog_threshold) {
+  ESP_LOGV(TAG, "Setting watchdog sensitivity to %d", watchdog_threshold);
+  if ((watchdog_threshold < 1) || (watchdog_threshold > 10))  // 10 is the max sensitivity setting
+    return;
+  this->write_register(THRESHOLD, THRESH_MASK, watchdog_threshold, 0);
+}
+
+// REG0x01, bits [6:4], manufacturer default: 010 (2).
+// The noise floor level is compared to a known reference voltage. If this
+// level is exceeded the chip will issue an interrupt to the IRQ pin,
+// broadcasting that it can not operate properly due to noise (INT_NH).
+// Check datasheet for specific noise level tolerances when setting this register.
+void AS3935Component::write_noise_level(uint8_t noise_level) {
+  ESP_LOGV(TAG, "Setting noise level to %d", noise_level);
+  if ((noise_level < 1) || (noise_level > 7))
+    return;
+
+  this->write_register(THRESHOLD, NOISE_FLOOR_MASK, noise_level, 4);
+}
+// REG0x02, bits [3:0], manufacturer default: 0010 (2).
+// This setting, like the watchdog threshold, can help determine between false
+// events and actual lightning. The shape of the spike is analyzed during the
+// chip's signal validation routine. Increasing this value increases robustness
+// at the cost of sensitivity to distant events.
+void AS3935Component::write_spike_rejection(uint8_t spike_rejection) {
+  ESP_LOGV(TAG, "Setting spike rejection to %d", spike_rejection);
+  if ((spike_rejection < 1) || (spike_rejection > 11))
+    return;
+
+  this->write_register(LIGHTNING_REG, SPIKE_MASK, spike_rejection, 0);
+}
+// REG0x02, bits [5:4], manufacturer default: 0 (single lightning strike).
+// The number of lightning events before IRQ is set high. 15 minutes is The
+// window of time before the number of detected lightning events is reset.
+// The number of lightning strikes can be set to 1,5,9, or 16.
+void AS3935Component::write_lightning_threshold(uint8_t lightning_threshold) {
+  ESP_LOGV(TAG, "Setting lightning threshold to %d", lightning_threshold);
+  switch (lightning_threshold) {
+    case 1:
+      this->write_register(LIGHTNING_REG, ((1 << 5) | (1 << 4)), 0, 4);  // Demonstrative
+      break;
+    case 5:
+      this->write_register(LIGHTNING_REG, ((1 << 5) | (1 << 4)), 1, 4);
+      break;
+    case 9:
+      this->write_register(LIGHTNING_REG, ((1 << 5) | (1 << 4)), 1, 5);
+      break;
+    case 16:
+      this->write_register(LIGHTNING_REG, ((1 << 5) | (1 << 4)), 3, 4);
+      break;
+    default:
+      return;
+  }
+}
+// REG0x03, bit [5], manufacturer default: 0.
+// This setting will return whether or not disturbers trigger the IRQ Pin.
+void AS3935Component::write_mask_disturber(bool enabled) {
+  ESP_LOGV(TAG, "Setting mask disturber to %d", enabled);
+  if (enabled) {
+    this->write_register(INT_MASK_ANT, (1 << 5), 1, 5);
+  } else {
+    this->write_register(INT_MASK_ANT, (1 << 5), 0, 5);
+  }
+}
+// REG0x03, bit [7:6], manufacturer default: 0 (16 division ratio).
+// The antenna is designed to resonate at 500kHz and so can be tuned with the
+// following setting. The accuracy of the antenna must be within 3.5 percent of
+// that value for proper signal validation and distance estimation.
+void AS3935Component::write_div_ratio(uint8_t div_ratio) {
+  ESP_LOGV(TAG, "Setting div ratio to %d", div_ratio);
+  switch (div_ratio) {
+    case 16:
+      this->write_register(INT_MASK_ANT, ((1 << 7) | (1 << 6)), 0, 6);
+      break;
+    case 22:
+      this->write_register(INT_MASK_ANT, ((1 << 7) | (1 << 6)), 1, 6);
+      break;
+    case 64:
+      this->write_register(INT_MASK_ANT, ((1 << 7) | (1 << 6)), 1, 7);
+      break;
+    case 128:
+      this->write_register(INT_MASK_ANT, ((1 << 7) | (1 << 6)), 3, 6);
+      break;
+    default:
+      return;
+  }
+}
+// REG0x08, bits [3:0], manufacturer default: 0.
+// This setting will add capacitance to the series RLC antenna on the product
+// to help tune its resonance. The datasheet specifies being within 3.5 percent
+// of 500kHz to get optimal lightning detection and distance sensing.
+// It's possible to add up to 120pF in steps of 8pF to the antenna.
+void AS3935Component::write_capacitance(uint8_t capacitance) {
+  ESP_LOGV(TAG, "Setting tune cap to %d pF", capacitance * 8);
+  this->write_register(FREQ_DISP_IRQ, CAP_MASK, capacitance, 0);
+}
+
+// REG0x03, bits [3:0], manufacturer default: 0.
+// When there is an event that exceeds the watchdog threshold, the register is written
+// with the type of event. This consists of two messages: INT_D (disturber detected) and
+// INT_L (Lightning detected). A third interrupt INT_NH (noise level too HIGH)
+// indicates that the noise level has been exceeded and will persist until the
+// noise has ended. Events are active HIGH. There is a one second window of time to
+// read the interrupt register after lightning is detected, and 1.5 after
+// disturber.
+uint8_t AS3935Component::read_interrupt_register_() {
+  // A 2ms delay is added to allow for the memory register to be populated
+  // after the interrupt pin goes HIGH. See "Interrupt Management" in
+  // datasheet.
+  ESP_LOGV(TAG, "Calling read_interrupt_register_");
+  delay(2);
+  return this->read_register_(INT_MASK_ANT, INT_MASK);
+}
+
+// REG0x02, bit [6], manufacturer default: 1.
+// This register clears the number of lightning strikes that has been read in
+// the last 15 minute block.
+void AS3935Component::clear_statistics_() {
+  // Write high, then low, then high to clear.
+  ESP_LOGV(TAG, "Calling clear_statistics_");
+  this->write_register(LIGHTNING_REG, (1 << 6), 1, 6);
+  this->write_register(LIGHTNING_REG, (1 << 6), 0, 6);
+  this->write_register(LIGHTNING_REG, (1 << 6), 1, 6);
+}
+
+// REG0x07, bit [5:0], manufacturer default: 0.
+// This register holds the distance to the front of the storm and not the
+// distance to a lightning strike.
+uint8_t AS3935Component::get_distance_to_storm_() {
+  ESP_LOGV(TAG, "Calling get_distance_to_storm_");
+  return this->read_register_(DISTANCE, DISTANCE_MASK);
+}
+
+uint32_t AS3935Component::get_lightning_energy_() {
+  ESP_LOGV(TAG, "Calling get_lightning_energy_");
+  uint32_t pure_light = 0;  // Variable for lightning energy which is just a pure number.
+  uint32_t temp = 0;
+  // Temp variable for lightning energy.
+  temp = this->read_register_(ENERGY_LIGHT_MMSB, ENERGY_MASK);
+  // Temporary Value is large enough to handle a shift of 16 bits.
+  pure_light = temp << 16;
+  temp = this->read_register(ENERGY_LIGHT_MSB);
+  // Temporary value is large enough to handle a shift of 8 bits.
+  pure_light |= temp << 8;
+  // No shift here, directly OR'ed into pure_light variable.
+  temp = this->read_register(ENERGY_LIGHT_LSB);
+  pure_light |= temp;
+  return pure_light;
+}
+
+uint8_t AS3935Component::read_register_(uint8_t reg, uint8_t mask) {
+  uint8_t value = this->read_register(reg);
+  value &= (~mask);
+  return value;
+}
+
+}  // namespace as3935
+}  // namespace esphome

esphome/components/as3935/as3935.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/binary_sensor/binary_sensor.h"
+
+namespace esphome {
+namespace as3935 {
+
+enum AS3935RegisterNames {
+  AFE_GAIN = 0x00,
+  THRESHOLD,
+  LIGHTNING_REG,
+  INT_MASK_ANT,
+  ENERGY_LIGHT_LSB,
+  ENERGY_LIGHT_MSB,
+  ENERGY_LIGHT_MMSB,
+  DISTANCE,
+  FREQ_DISP_IRQ,
+  CALIB_TRCO = 0x3A,
+  CALIB_SRCO = 0x3B,
+  DEFAULT_RESET = 0x3C,
+  CALIB_RCO = 0x3D
+};
+
+enum AS3935RegisterMasks {
+  GAIN_MASK = 0x3E,
+  SPIKE_MASK = 0xF,
+  IO_MASK = 0xC1,
+  DISTANCE_MASK = 0xC0,
+  INT_MASK = 0xF0,
+  THRESH_MASK = 0x0F,
+  R_SPIKE_MASK = 0xF0,
+  ENERGY_MASK = 0xF0,
+  CAP_MASK = 0xF0,
+  LIGHT_MASK = 0xCF,
+  DISTURB_MASK = 0xDF,
+  NOISE_FLOOR_MASK = 0x70,
+  OSC_MASK = 0xE0,
+  CALIB_MASK = 0x7F,
+  DIV_MASK = 0x3F
+};
+
+enum AS3935Values {
+  AS3935_ADDR = 0x03,
+  INDOOR = 0x12,
+  OUTDOOR = 0xE,
+  LIGHTNING_INT = 0x08,
+  DISTURBER_INT = 0x04,
+  NOISE_INT = 0x01
+};
+
+class AS3935Component : public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void loop() override;
+
+  void set_irq_pin(GPIOPin *irq_pin) { irq_pin_ = irq_pin; }
+  void set_distance_sensor(sensor::Sensor *distance_sensor) { distance_sensor_ = distance_sensor; }
+  void set_energy_sensor(sensor::Sensor *energy_sensor) { energy_sensor_ = energy_sensor; }
+  void set_thunder_alert_binary_sensor(binary_sensor::BinarySensor *thunder_alert_binary_sensor) {
+    thunder_alert_binary_sensor_ = thunder_alert_binary_sensor;
+  }
+  void set_indoor(bool indoor) { indoor_ = indoor; }
+  void write_indoor(bool indoor);
+  void set_noise_level(uint8_t noise_level) { noise_level_ = noise_level; }
+  void write_noise_level(uint8_t noise_level);
+  void set_watchdog_threshold(uint8_t watchdog_threshold) { watchdog_threshold_ = watchdog_threshold; }
+  void write_watchdog_threshold(uint8_t watchdog_threshold);
+  void set_spike_rejection(uint8_t spike_rejection) { spike_rejection_ = spike_rejection; }
+  void write_spike_rejection(uint8_t write_spike_rejection);
+  void set_lightning_threshold(uint8_t lightning_threshold) { lightning_threshold_ = lightning_threshold; }
+  void write_lightning_threshold(uint8_t lightning_threshold);
+  void set_mask_disturber(bool mask_disturber) { mask_disturber_ = mask_disturber; }
+  void write_mask_disturber(bool enabled);
+  void set_div_ratio(uint8_t div_ratio) { div_ratio_ = div_ratio; }
+  void write_div_ratio(uint8_t div_ratio);
+  void set_capacitance(uint8_t capacitance) { capacitance_ = capacitance; }
+  void write_capacitance(uint8_t capacitance);
+
+ protected:
+  uint8_t read_interrupt_register_();
+  void clear_statistics_();
+  uint8_t get_distance_to_storm_();
+  uint32_t get_lightning_energy_();
+
+  virtual uint8_t read_register(uint8_t reg) = 0;
+  uint8_t read_register_(uint8_t reg, uint8_t mask);
+
+  virtual void write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_position) = 0;
+
+  sensor::Sensor *distance_sensor_;
+  sensor::Sensor *energy_sensor_;
+  binary_sensor::BinarySensor *thunder_alert_binary_sensor_;
+  GPIOPin *irq_pin_;
+
+  bool indoor_;
+  uint8_t noise_level_;
+  uint8_t watchdog_threshold_;
+  uint8_t spike_rejection_;
+  uint8_t lightning_threshold_;
+  bool mask_disturber_;
+  uint8_t div_ratio_;
+  uint8_t capacitance_;
+};
+
+}  // namespace as3935
+}  // namespace esphome

esphome/components/as3935/binary_sensor.py

@@ -0,0 +1,18 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import binary_sensor
+from . import AS3935, CONF_AS3935_ID
+
+DEPENDENCIES = ["as3935"]
+
+CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_AS3935_ID): cv.use_id(AS3935),
+    }
+)
+
+
+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

@@ -0,0 +1,46 @@
+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,
+    DEVICE_CLASS_EMPTY,
+    STATE_CLASS_NONE,
+    UNIT_KILOMETER,
+    UNIT_EMPTY,
+    ICON_SIGNAL_DISTANCE_VARIANT,
+    ICON_FLASH,
+)
+from . import AS3935, CONF_AS3935_ID
+
+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,
+            DEVICE_CLASS_EMPTY,
+            STATE_CLASS_NONE,
+        ),
+        cv.Optional(CONF_LIGHTNING_ENERGY): sensor.sensor_schema(
+            UNIT_EMPTY, ICON_FLASH, 1, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+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 = 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 = await sensor.new_sensor(conf)
+        cg.add(hub.set_energy_sensor(lightning_energy_sensor))

esphome/components/as3935_i2c/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import as3935, i2c
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["i2c"]
+
+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))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await as3935.setup_as3935(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/as3935_i2c/as3935_i2c.cpp

@@ -0,0 +1,40 @@
+#include "as3935_i2c.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace as3935_i2c {
+
+static const char *TAG = "as3935_i2c";
+
+void I2CAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_pos) {
+  uint8_t write_reg;
+  if (!this->read_byte(reg, &write_reg)) {
+    this->mark_failed();
+    ESP_LOGW(TAG, "read_byte failed - increase log level for more details!");
+    return;
+  }
+
+  write_reg &= (~mask);
+  write_reg |= (bits << start_pos);
+
+  if (!this->write_byte(reg, write_reg)) {
+    ESP_LOGW(TAG, "write_byte failed - increase log level for more details!");
+    return;
+  }
+}
+
+uint8_t I2CAS3935Component::read_register(uint8_t reg) {
+  uint8_t value;
+  if (!this->read_byte(reg, &value, 2)) {
+    ESP_LOGW(TAG, "Read failed!");
+    return 0;
+  }
+  return value;
+}
+void I2CAS3935Component::dump_config() {
+  AS3935Component::dump_config();
+  LOG_I2C_DEVICE(this);
+}
+
+}  // namespace as3935_i2c
+}  // namespace esphome

esphome/components/as3935_i2c/as3935_i2c.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/as3935/as3935.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/binary_sensor/binary_sensor.h"
+
+namespace esphome {
+namespace as3935_i2c {
+
+class I2CAS3935Component : public as3935::AS3935Component, public i2c::I2CDevice {
+ public:
+  void dump_config() override;
+
+ protected:
+  void write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_position) override;
+  uint8_t read_register(uint8_t reg) override;
+};
+
+}  // namespace as3935_i2c
+}  // namespace esphome

esphome/components/as3935_spi/__init__.py

@@ -0,0 +1,26 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import as3935, spi
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["as3935"]
+DEPENDENCIES = ["spi"]
+
+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))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await as3935.setup_as3935(var, config)
+    await spi.register_spi_device(var, config)

esphome/components/as3935_spi/as3935_spi.cpp

@@ -0,0 +1,48 @@
+#include "as3935_spi.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace as3935_spi {
+
+static const char *TAG = "as3935_spi";
+
+void SPIAS3935Component::setup() {
+  ESP_LOGI(TAG, "SPIAS3935Component setup started!");
+  this->spi_setup();
+  ESP_LOGI(TAG, "SPI setup finished!");
+  AS3935Component::setup();
+}
+
+void SPIAS3935Component::dump_config() {
+  AS3935Component::dump_config();
+  LOG_PIN("  CS Pin: ", this->cs_);
+}
+
+void SPIAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_pos) {
+  uint8_t write_reg = this->read_register(reg);
+
+  write_reg &= (~mask);
+  write_reg |= (bits << start_pos);
+
+  this->enable();
+  this->write_byte(reg);
+  this->write_byte(write_reg);
+  this->disable();
+}
+
+uint8_t SPIAS3935Component::read_register(uint8_t reg) {
+  uint8_t value = 0;
+  this->enable();
+  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.
+  this->cs_->digital_write(true);
+  this->cs_->digital_write(false);
+  this->disable();
+  ESP_LOGV(TAG, "read_register_: %d", value);
+  return value;
+}
+
+}  // namespace as3935_spi
+}  // namespace esphome

esphome/components/as3935_spi/as3935_spi.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/as3935/as3935.h"
+#include "esphome/components/spi/spi.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/binary_sensor/binary_sensor.h"
+
+namespace esphome {
+namespace as3935_spi {
+
+enum AS3935RegisterMasks { SPI_READ_M = 0x40 };
+
+class SPIAS3935Component : public as3935::AS3935Component,
+                           public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
+                                                 spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_2MHZ> {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  void write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_position) override;
+  uint8_t read_register(uint8_t reg) override;
+};
+
+}  // namespace as3935_spi
+}  // namespace esphome

esphome/components/async_tcp/__init__.py

@@ -0,0 +1,15 @@
+# Dummy integration to allow relying on AsyncTCP
+import esphome.codegen as cg
+from esphome.core import CORE, coroutine_with_priority
+
+CODEOWNERS = ["@OttoWinter"]
+
+
+@coroutine_with_priority(200.0)
+async def to_code(config):
+    if CORE.is_esp32:
+        # https://github.com/esphome/AsyncTCP/blob/master/library.json
+        cg.add_library("esphome/AsyncTCP-esphome", "1.2.2")
+    elif CORE.is_esp8266:
+        # https://github.com/OttoWinter/ESPAsyncTCP
+        cg.add_library("ESPAsyncTCP-esphome", "1.2.3")

esphome/components/atc_mithermometer/atc_mithermometer.cpp

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

esphome/components/atc_mithermometer/atc_mithermometer.h

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

esphome/components/atc_mithermometer/sensor.py

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

esphome/components/atm90e32/atm90e32.cpp

@@ -0,0 +1,299 @@
+#include "atm90e32.h"
+#include "atm90e32_reg.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace atm90e32 {
+
+static const char *TAG = "atm90e32";
+
+void ATM90E32Component::update() {
+  if (this->read16_(ATM90E32_REGISTER_METEREN) != 1) {
+    this->status_set_warning();
+    return;
+  }
+
+  if (this->phase_[0].voltage_sensor_ != nullptr) {
+    this->phase_[0].voltage_sensor_->publish_state(this->get_line_voltage_a_());
+  }
+  if (this->phase_[1].voltage_sensor_ != nullptr) {
+    this->phase_[1].voltage_sensor_->publish_state(this->get_line_voltage_b_());
+  }
+  if (this->phase_[2].voltage_sensor_ != nullptr) {
+    this->phase_[2].voltage_sensor_->publish_state(this->get_line_voltage_c_());
+  }
+  if (this->phase_[0].current_sensor_ != nullptr) {
+    this->phase_[0].current_sensor_->publish_state(this->get_line_current_a_());
+  }
+  if (this->phase_[1].current_sensor_ != nullptr) {
+    this->phase_[1].current_sensor_->publish_state(this->get_line_current_b_());
+  }
+  if (this->phase_[2].current_sensor_ != nullptr) {
+    this->phase_[2].current_sensor_->publish_state(this->get_line_current_c_());
+  }
+  if (this->phase_[0].power_sensor_ != nullptr) {
+    this->phase_[0].power_sensor_->publish_state(this->get_active_power_a_());
+  }
+  if (this->phase_[1].power_sensor_ != nullptr) {
+    this->phase_[1].power_sensor_->publish_state(this->get_active_power_b_());
+  }
+  if (this->phase_[2].power_sensor_ != nullptr) {
+    this->phase_[2].power_sensor_->publish_state(this->get_active_power_c_());
+  }
+  if (this->phase_[0].reactive_power_sensor_ != nullptr) {
+    this->phase_[0].reactive_power_sensor_->publish_state(this->get_reactive_power_a_());
+  }
+  if (this->phase_[1].reactive_power_sensor_ != nullptr) {
+    this->phase_[1].reactive_power_sensor_->publish_state(this->get_reactive_power_b_());
+  }
+  if (this->phase_[2].reactive_power_sensor_ != nullptr) {
+    this->phase_[2].reactive_power_sensor_->publish_state(this->get_reactive_power_c_());
+  }
+  if (this->phase_[0].power_factor_sensor_ != nullptr) {
+    this->phase_[0].power_factor_sensor_->publish_state(this->get_power_factor_a_());
+  }
+  if (this->phase_[1].power_factor_sensor_ != nullptr) {
+    this->phase_[1].power_factor_sensor_->publish_state(this->get_power_factor_b_());
+  }
+  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_());
+  }
+  if (this->chip_temperature_sensor_ != nullptr) {
+    this->chip_temperature_sensor_->publish_state(this->get_chip_temperature_());
+  }
+  this->status_clear_warning();
+}
+
+void ATM90E32Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ATM90E32 Component...");
+  this->spi_setup();
+
+  uint16_t mmode0 = 0x87;  // 3P4W 50Hz
+  if (line_freq_ == 60) {
+    mmode0 |= 1 << 12;  // sets 12th bit to 1, 60Hz
+  }
+
+  if (current_phases_ == 2) {
+    mmode0 |= 1 << 8;  // sets 8th bit to 1, 3P3W
+    mmode0 |= 0 << 1;  // sets 1st bit to 0, phase b is not counted into the all-phase sum energy/power (P/Q/S)
+  }
+
+  this->write16_(ATM90E32_REGISTER_SOFTRESET, 0x789A);    // Perform soft reset
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);  // enable register config access
+  this->write16_(ATM90E32_REGISTER_METEREN, 0x0001);      // Enable Metering
+  if (this->read16_(ATM90E32_REGISTER_LASTSPIDATA) != 0x0001) {
+    ESP_LOGW(TAG, "Could not initialize ATM90E32 IC, check SPI settings");
+    this->mark_failed();
+    return;
+  }
+  this->write16_(ATM90E32_REGISTER_PLCONSTH, 0x0861);   // PL Constant MSB (default) = 140625000
+  this->write16_(ATM90E32_REGISTER_PLCONSTL, 0xC468);   // PL Constant LSB (default)
+  this->write16_(ATM90E32_REGISTER_ZXCONFIG, 0xD654);   // ZX2, ZX1, ZX0 pin config
+  this->write16_(ATM90E32_REGISTER_MMODE0, mmode0);     // Mode Config (frequency set in main program)
+  this->write16_(ATM90E32_REGISTER_MMODE1, pga_gain_);  // PGA Gain Configuration for Current Channels
+  this->write16_(ATM90E32_REGISTER_PSTARTTH, 0x1D4C);   // All Active Startup Power Threshold - 0.02A/0.00032 = 7500
+  this->write16_(ATM90E32_REGISTER_QSTARTTH, 0x1D4C);   // All Reactive Startup Power Threshold - 50%
+  this->write16_(ATM90E32_REGISTER_PPHASETH, 0x02EE);   // Each Phase Active Phase Threshold - 0.002A/0.00032 = 750
+  this->write16_(ATM90E32_REGISTER_QPHASETH, 0x02EE);   // Each phase Reactive Phase Threshold - 10%
+  this->write16_(ATM90E32_REGISTER_UGAINA, this->phase_[0].volt_gain_);  // A Voltage rms gain
+  this->write16_(ATM90E32_REGISTER_IGAINA, this->phase_[0].ct_gain_);    // A line current gain
+  this->write16_(ATM90E32_REGISTER_UGAINB, this->phase_[1].volt_gain_);  // B Voltage rms gain
+  this->write16_(ATM90E32_REGISTER_IGAINB, this->phase_[1].ct_gain_);    // B line current gain
+  this->write16_(ATM90E32_REGISTER_UGAINC, this->phase_[2].volt_gain_);  // C Voltage rms gain
+  this->write16_(ATM90E32_REGISTER_IGAINC, this->phase_[2].ct_gain_);    // C line current gain
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);                 // end configuration
+}
+
+void ATM90E32Component::dump_config() {
+  ESP_LOGCONFIG("", "ATM90E32:");
+  LOG_PIN("  CS Pin: ", this->cs_);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with ATM90E32 failed!");
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Voltage A", this->phase_[0].voltage_sensor_);
+  LOG_SENSOR("  ", "Current A", this->phase_[0].current_sensor_);
+  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_);
+}
+float ATM90E32Component::get_setup_priority() const { return setup_priority::DATA; }
+
+uint16_t ATM90E32Component::read16_(uint16_t a_register) {
+  uint8_t addrh = (1 << 7) | ((a_register >> 8) & 0x03);
+  uint8_t addrl = (a_register & 0xFF);
+  uint8_t data[2];
+  uint16_t output;
+
+  this->enable();
+  delayMicroseconds(10);
+  this->write_byte(addrh);
+  this->write_byte(addrl);
+  delayMicroseconds(4);
+  this->read_array(data, 2);
+  this->disable();
+
+  output = (uint16_t(data[0] & 0xFF) << 8) | (data[1] & 0xFF);
+  ESP_LOGVV(TAG, "read16_ 0x%04X output 0x%04X", a_register, output);
+  return output;
+}
+
+int ATM90E32Component::read32_(uint16_t addr_h, uint16_t addr_l) {
+  uint16_t val_h = this->read16_(addr_h);
+  uint16_t val_l = this->read16_(addr_l);
+  int32_t val = (val_h << 16) | val_l;
+
+  ESP_LOGVV(TAG, "read32_ addr_h 0x%04X val_h 0x%04X addr_l 0x%04X val_l 0x%04X = %d", addr_h, val_h, addr_l, val_l,
+            val);
+
+  return val;
+}
+
+void ATM90E32Component::write16_(uint16_t a_register, uint16_t val) {
+  uint8_t addrh = (a_register >> 8) & 0x03;
+  uint8_t addrl = (a_register & 0xFF);
+
+  ESP_LOGVV(TAG, "write16_ 0x%04X val 0x%04X", a_register, val);
+  this->enable();
+  delayMicroseconds(10);
+  this->write_byte(addrh);
+  this->write_byte(addrl);
+  delayMicroseconds(4);
+  this->write_byte((val >> 8) & 0xff);
+  this->write_byte(val & 0xFF);
+  this->disable();
+}
+
+float ATM90E32Component::get_line_voltage_a_() {
+  uint16_t voltage = this->read16_(ATM90E32_REGISTER_URMSA);
+  return (float) voltage / 100;
+}
+float ATM90E32Component::get_line_voltage_b_() {
+  uint16_t voltage = this->read16_(ATM90E32_REGISTER_URMSB);
+  return (float) voltage / 100;
+}
+float ATM90E32Component::get_line_voltage_c_() {
+  uint16_t voltage = this->read16_(ATM90E32_REGISTER_URMSC);
+  return (float) voltage / 100;
+}
+float ATM90E32Component::get_line_current_a_() {
+  uint16_t current = this->read16_(ATM90E32_REGISTER_IRMSA);
+  return (float) current / 1000;
+}
+float ATM90E32Component::get_line_current_b_() {
+  uint16_t current = this->read16_(ATM90E32_REGISTER_IRMSB);
+  return (float) current / 1000;
+}
+float ATM90E32Component::get_line_current_c_() {
+  uint16_t current = this->read16_(ATM90E32_REGISTER_IRMSC);
+  return (float) current / 1000;
+}
+float ATM90E32Component::get_active_power_a_() {
+  int val = this->read32_(ATM90E32_REGISTER_PMEANA, ATM90E32_REGISTER_PMEANALSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_active_power_b_() {
+  int val = this->read32_(ATM90E32_REGISTER_PMEANB, ATM90E32_REGISTER_PMEANBLSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_active_power_c_() {
+  int val = this->read32_(ATM90E32_REGISTER_PMEANC, ATM90E32_REGISTER_PMEANCLSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_reactive_power_a_() {
+  int val = this->read32_(ATM90E32_REGISTER_QMEANA, ATM90E32_REGISTER_QMEANALSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_reactive_power_b_() {
+  int val = this->read32_(ATM90E32_REGISTER_QMEANB, ATM90E32_REGISTER_QMEANBLSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_reactive_power_c_() {
+  int val = this->read32_(ATM90E32_REGISTER_QMEANC, ATM90E32_REGISTER_QMEANCLSB);
+  return val * 0.00032f;
+}
+float ATM90E32Component::get_power_factor_a_() {
+  int16_t pf = this->read16_(ATM90E32_REGISTER_PFMEANA);
+  return (float) pf / 1000;
+}
+float ATM90E32Component::get_power_factor_b_() {
+  int16_t pf = this->read16_(ATM90E32_REGISTER_PFMEANB);
+  return (float) pf / 1000;
+}
+float ATM90E32Component::get_power_factor_c_() {
+  int16_t pf = this->read16_(ATM90E32_REGISTER_PFMEANC);
+  return (float) pf / 1000;
+}
+float ATM90E32Component::get_forward_active_energy_a_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYA);
+  return (float) val * 10 / 3200;  // convert register value to WattHours
+}
+float ATM90E32Component::get_forward_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYB);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_forward_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_APENERGYC);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_a_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYA);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_b_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYB);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_reverse_active_energy_c_() {
+  uint16_t val = this->read16_(ATM90E32_REGISTER_ANENERGYC);
+  return (float) val * 10 / 3200;
+}
+float ATM90E32Component::get_frequency_() {
+  uint16_t freq = this->read16_(ATM90E32_REGISTER_FREQ);
+  return (float) freq / 100;
+}
+float ATM90E32Component::get_chip_temperature_() {
+  uint16_t ctemp = this->read16_(ATM90E32_REGISTER_TEMP);
+  return (float) ctemp;
+}
+}  // namespace atm90e32
+}  // namespace esphome

esphome/components/atm90e32/atm90e32.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/spi/spi.h"
+
+namespace esphome {
+namespace atm90e32 {
+
+class ATM90E32Component : public PollingComponent,
+                          public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
+                                                spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_200KHZ> {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void update() override;
+
+  void set_voltage_sensor(int phase, sensor::Sensor *obj) { this->phase_[phase].voltage_sensor_ = obj; }
+  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; }
+
+  void set_freq_sensor(sensor::Sensor *freq_sensor) { freq_sensor_ = freq_sensor; }
+  void set_chip_temperature_sensor(sensor::Sensor *chip_temperature_sensor) {
+    chip_temperature_sensor_ = chip_temperature_sensor;
+  }
+  void set_line_freq(int freq) { line_freq_ = freq; }
+  void set_current_phases(int phases) { current_phases_ = phases; }
+  void set_pga_gain(uint16_t gain) { pga_gain_ = gain; }
+
+ protected:
+  uint16_t read16_(uint16_t a_register);
+  int read32_(uint16_t addr_h, uint16_t addr_l);
+  void write16_(uint16_t a_register, uint16_t val);
+
+  float get_line_voltage_a_();
+  float get_line_voltage_b_();
+  float get_line_voltage_c_();
+  float get_line_current_a_();
+  float get_line_current_b_();
+  float get_line_current_c_();
+  float get_active_power_a_();
+  float get_active_power_b_();
+  float get_active_power_c_();
+  float get_reactive_power_a_();
+  float get_reactive_power_b_();
+  float get_reactive_power_c_();
+  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_();
+
+  struct ATM90E32Phase {
+    uint16_t volt_gain_{7305};
+    uint16_t ct_gain_{27961};
+    sensor::Sensor *voltage_sensor_{nullptr};
+    sensor::Sensor *current_sensor_{nullptr};
+    sensor::Sensor *power_sensor_{nullptr};
+    sensor::Sensor *reactive_power_sensor_{nullptr};
+    sensor::Sensor *power_factor_sensor_{nullptr};
+    sensor::Sensor *forward_active_energy_sensor_{nullptr};
+    sensor::Sensor *reverse_active_energy_sensor_{nullptr};
+  } phase_[3];
+  sensor::Sensor *freq_sensor_{nullptr};
+  sensor::Sensor *chip_temperature_sensor_{nullptr};
+  uint16_t pga_gain_{0x15};
+  int line_freq_{60};
+  int current_phases_{3};
+};
+
+}  // namespace atm90e32
+}  // namespace esphome

esphome/components/atm90e32/atm90e32_reg.h

@@ -0,0 +1,253 @@
+#pragma once
+
+namespace esphome {
+namespace atm90e32 {
+
+/* STATUS REGISTERS */
+static const uint16_t ATM90E32_REGISTER_METEREN = 0x00;        // Metering Enable
+static const uint16_t ATM90E32_REGISTER_CHANNELMAPI = 0x01;    // Current Channel Mapping Configuration
+static const uint16_t ATM90E32_REGISTER_CHANNELMAPU = 0x02;    // Voltage Channel Mapping Configuration
+static const uint16_t ATM90E32_REGISTER_SAGPEAKDETCFG = 0x05;  // Sag and Peak Detector Period Configuration
+static const uint16_t ATM90E32_REGISTER_OVTH = 0x06;           // Over Voltage Threshold
+static const uint16_t ATM90E32_REGISTER_ZXCONFIG = 0x07;       // Zero-Crossing Config
+static const uint16_t ATM90E32_REGISTER_SAGTH = 0x08;          // Voltage Sag Th
+static const uint16_t ATM90E32_REGISTER_PHASELOSSTH = 0x09;    // Voltage Phase Losing Th
+static const uint16_t ATM90E32_REGISTER_INWARNTH = 0x0A;       // Neutral Current (Calculated) Warning Threshold
+static const uint16_t ATM90E32_REGISTER_OITH = 0x0B;           // Over Current Threshold
+static const uint16_t ATM90E32_REGISTER_FREQLOTH = 0x0C;       // Low Threshold for Frequency Detection
+static const uint16_t ATM90E32_REGISTER_FREQHITH = 0x0D;       // High Threshold for Frequency Detection
+static const uint16_t ATM90E32_REGISTER_PMPWRCTRL = 0x0E;      // Partial Measurement Mode Power Control
+static const uint16_t ATM90E32_REGISTER_IRQ0MERGECFG = 0x0F;   // IRQ0 Merge Configuration
+
+/* EMM STATUS REGISTERS */
+static const uint16_t ATM90E32_REGISTER_SOFTRESET = 0x70;       // Software Reset
+static const uint16_t ATM90E32_REGISTER_EMMSTATE0 = 0x71;       // EMM State 0
+static const uint16_t ATM90E32_REGISTER_EMMSTATE1 = 0x72;       // EMM State 1
+static const uint16_t ATM90E32_REGISTER_EMMINTSTATE0 = 0x73;    // EMM Interrupt Status 0
+static const uint16_t ATM90E32_REGISTER_EMMINTSTATE1 = 0x74;    // EMM Interrupt Status 1
+static const uint16_t ATM90E32_REGISTER_EMMINTEN0 = 0x75;       // EMM Interrupt Enable 0
+static const uint16_t ATM90E32_REGISTER_EMMINTEN1 = 0x76;       // EMM Interrupt Enable 1
+static const uint16_t ATM90E32_REGISTER_LASTSPIDATA = 0x78;     // Last Read/Write SPI Value
+static const uint16_t ATM90E32_REGISTER_CRCERRSTATUS = 0x79;    // CRC Error Status
+static const uint16_t ATM90E32_REGISTER_CRCDIGEST = 0x7A;       // CRC Digest
+static const uint16_t ATM90E32_REGISTER_CFGREGACCEN = 0x7F;     // Configure Register Access Enable
+static const uint16_t ATM90E32_STATUS_S0_OIPHASEAST = 1 << 15;  // Over current on phase A
+static const uint16_t ATM90E32_STATUS_S0_OIPHASEBST = 1 << 14;  // Over current on phase B
+static const uint16_t ATM90E32_STATUS_S0_OIPHASECST = 1 << 13;  // Over current on phase C
+static const uint16_t ATM90E32_STATUS_S0_OVPHASEAST = 1 << 12;  // Over voltage on phase A
+static const uint16_t ATM90E32_STATUS_S0_OVPHASEBST = 1 << 11;  // Over voltage on phase B
+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_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
+static const uint16_t ATM90E32_STATUS_S0_CF1REVST = 1 << 3;     // Energy for CF1 Forward/Reverse status
+static const uint16_t ATM90E32_STATUS_S0_CF2REVST = 1 << 2;     // Energy for CF2 Forward/Reverse status
+static const uint16_t ATM90E32_STATUS_S0_CF3REVST = 1 << 1;     // Energy for CF3 Forward/Reverse status
+static const uint16_t ATM90E32_STATUS_S0_CF4REVST = 1 << 0;     // Energy for CF4 Forward/Reverse status
+static const uint16_t ATM90E32_STATUS_S1_FREQHIST = 1 << 15;    // Frequency is greater than the high threshold
+static const uint16_t ATM90E32_STATUS_S1_SAGPHASEAST = 1 << 14;   // Voltage sag on phase A
+static const uint16_t ATM90E32_STATUS_S1_SAGPHASEBST = 1 << 13;   // Voltage sag on phase B
+static const uint16_t ATM90E32_STATUS_S1_SAGPHASECST = 1 << 12;   // Voltage sag on phase C
+static const uint16_t ATM90E32_STATUS_S1_FREQLOST = 1 << 11;      // Frequency is lesser than the low threshold
+static const uint16_t ATM90E32_STATUS_S1_PHASELOSSAST = 1 << 10;  // Phase loss in Phase A
+static const uint16_t ATM90E32_STATUS_S1_PHASELOSSBST = 1 << 9;   // Phase loss in Phase B
+static const uint16_t ATM90E32_STATUS_S1_PHASELOSSCST = 1 << 8;   // Phase loss in Phase C
+static const uint16_t ATM90E32_STATUS_S1_QEREGTPST = 1 << 7;      // ReActive Energy register of sum (T) Positive Status
+static const uint16_t ATM90E32_STATUS_S1_QEREGAPST = 1 << 6;  // ReActive Energy register of Channel A Positive Status
+static const uint16_t ATM90E32_STATUS_S1_QEREGBPST = 1 << 5;  // ReActive Energy register of Channel B Positive Status
+static const uint16_t ATM90E32_STATUS_S1_QEREGCPST = 1 << 4;  // ReActive Energy register of Channel C Positive Status
+static const uint16_t ATM90E32_STATUS_S1_PEREGTPST = 1 << 3;  // Active Energy register of sum (T) Positive Status
+static const uint16_t ATM90E32_STATUS_S1_PEREGAPST = 1 << 2;  // Active Energy register of Channel A Positive Status
+static const uint16_t ATM90E32_STATUS_S1_PEREGBPST = 1 << 1;  // Active Energy register of Channel B Positive Status
+static const uint16_t ATM90E32_STATUS_S1_PEREGCPST = 1 << 0;  // Active Energy register of Channel C Positive Status
+
+/* LOW POWER MODE REGISTERS - NOT USED */
+static const uint16_t ATM90E32_REGISTER_DETECTCTRL = 0x10;
+static const uint16_t ATM90E32_REGISTER_DETECTTH1 = 0x11;
+static const uint16_t ATM90E32_REGISTER_DETECTTH2 = 0x12;
+static const uint16_t ATM90E32_REGISTER_DETECTTH3 = 0x13;
+static const uint16_t ATM90E32_REGISTER_PMOFFSETA = 0x14;
+static const uint16_t ATM90E32_REGISTER_PMOFFSETB = 0x15;
+static const uint16_t ATM90E32_REGISTER_PMOFFSETC = 0x16;
+static const uint16_t ATM90E32_REGISTER_PMPGA = 0x17;
+static const uint16_t ATM90E32_REGISTER_PMIRMSA = 0x18;
+static const uint16_t ATM90E32_REGISTER_PMIRMSB = 0x19;
+static const uint16_t ATM90E32_REGISTER_PMIRMSC = 0x1A;
+static const uint16_t ATM90E32_REGISTER_PMCONFIG = 0x10B;
+static const uint16_t ATM90E32_REGISTER_PMAVGSAMPLES = 0x1C;
+static const uint16_t ATM90E32_REGISTER_PMIRMSLSB = 0x1D;
+
+/* CONFIGURATION REGISTERS */
+static const uint16_t ATM90E32_REGISTER_PLCONSTH = 0x31;  // High Word of PL_Constant
+static const uint16_t ATM90E32_REGISTER_PLCONSTL = 0x32;  // Low Word of PL_Constant
+static const uint16_t ATM90E32_REGISTER_MMODE0 = 0x33;    // Metering Mode Config
+static const uint16_t ATM90E32_REGISTER_MMODE1 = 0x34;    // PGA Gain Configuration for Current Channels
+static const uint16_t ATM90E32_REGISTER_PSTARTTH = 0x35;  // Startup Power Th (P)
+static const uint16_t ATM90E32_REGISTER_QSTARTTH = 0x36;  // Startup Power Th (Q)
+static const uint16_t ATM90E32_REGISTER_SSTARTTH = 0x37;  // Startup Power Th (S)
+static const uint16_t ATM90E32_REGISTER_PPHASETH = 0x38;  // Startup Power Accum Th (P)
+static const uint16_t ATM90E32_REGISTER_QPHASETH = 0x39;  // Startup Power Accum Th (Q)
+static const uint16_t ATM90E32_REGISTER_SPHASETH = 0x3A;  // Startup Power Accum Th (S)
+
+/* CALIBRATION REGISTERS */
+static const uint16_t ATM90E32_REGISTER_POFFSETA = 0x41;  // A Line Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_QOFFSETA = 0x42;  // A Line Power Offset (Q)
+static const uint16_t ATM90E32_REGISTER_POFFSETB = 0x43;  // B Line Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_QOFFSETB = 0x44;  // B Line Power Offset (Q)
+static const uint16_t ATM90E32_REGISTER_POFFSETC = 0x45;  // C Line Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_QOFFSETC = 0x46;  // C Line Power Offset (Q)
+static const uint16_t ATM90E32_REGISTER_PQGAINA = 0x47;   // A Line Calibration Gain
+static const uint16_t ATM90E32_REGISTER_PHIA = 0x48;      // A Line Calibration Angle
+static const uint16_t ATM90E32_REGISTER_PQGAINB = 0x49;   // B Line Calibration Gain
+static const uint16_t ATM90E32_REGISTER_PHIB = 0x4A;      // B Line Calibration Angle
+static const uint16_t ATM90E32_REGISTER_PQGAINC = 0x4B;   // C Line Calibration Gain
+static const uint16_t ATM90E32_REGISTER_PHIC = 0x4C;      // C Line Calibration Angle
+
+/* FUNDAMENTAL/HARMONIC ENERGY CALIBRATION REGISTERS */
+static const uint16_t ATM90E32_REGISTER_POFFSETAF = 0x51;  // A Fund Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_POFFSETBF = 0x52;  // B Fund Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_POFFSETCF = 0x53;  // C Fund Power Offset (P)
+static const uint16_t ATM90E32_REGISTER_PGAINAF = 0x54;    // A Fund Power Gain (P)
+static const uint16_t ATM90E32_REGISTER_PGAINBF = 0x55;    // B Fund Power Gain (P)
+static const uint16_t ATM90E32_REGISTER_PGAINCF = 0x56;    // C Fund Power Gain (P)
+
+/* MEASUREMENT CALIBRATION REGISTERS */
+static const uint16_t ATM90E32_REGISTER_UGAINA = 0x61;    // A Voltage RMS Gain
+static const uint16_t ATM90E32_REGISTER_IGAINA = 0x62;    // A Current RMS Gain
+static const uint16_t ATM90E32_REGISTER_UOFFSETA = 0x63;  // A Voltage Offset
+static const uint16_t ATM90E32_REGISTER_IOFFSETA = 0x64;  // A Current Offset
+static const uint16_t ATM90E32_REGISTER_UGAINB = 0x65;    // B Voltage RMS Gain
+static const uint16_t ATM90E32_REGISTER_IGAINB = 0x66;    // B Current RMS Gain
+static const uint16_t ATM90E32_REGISTER_UOFFSETB = 0x67;  // B Voltage Offset
+static const uint16_t ATM90E32_REGISTER_IOFFSETB = 0x68;  // B Current Offset
+static const uint16_t ATM90E32_REGISTER_UGAINC = 0x69;    // C Voltage RMS Gain
+static const uint16_t ATM90E32_REGISTER_IGAINC = 0x6A;    // C Current RMS Gain
+static const uint16_t ATM90E32_REGISTER_UOFFSETC = 0x6B;  // C Voltage Offset
+static const uint16_t ATM90E32_REGISTER_IOFFSETC = 0x6C;  // C Current Offset
+static const uint16_t ATM90E32_REGISTER_IOFFSETN = 0x6E;  // N Current Offset
+
+/* ENERGY REGISTERS */
+static const uint16_t ATM90E32_REGISTER_APENERGYT = 0x80;  // Total Forward Active
+static const uint16_t ATM90E32_REGISTER_APENERGYA = 0x81;  // A Forward Active
+static const uint16_t ATM90E32_REGISTER_APENERGYB = 0x82;  // B Forward Active
+static const uint16_t ATM90E32_REGISTER_APENERGYC = 0x83;  // C Forward Active
+static const uint16_t ATM90E32_REGISTER_ANENERGYT = 0x84;  // Total Reverse Active
+static const uint16_t ATM90E32_REGISTER_ANENERGYA = 0x85;  // A Reverse Active
+static const uint16_t ATM90E32_REGISTER_ANENERGYB = 0x86;  // B Reverse Active
+static const uint16_t ATM90E32_REGISTER_ANENERGYC = 0x87;  // C Reverse Active
+static const uint16_t ATM90E32_REGISTER_RPENERGYT = 0x88;  // Total Forward Reactive
+static const uint16_t ATM90E32_REGISTER_RPENERGYA = 0x89;  // A Forward Reactive
+static const uint16_t ATM90E32_REGISTER_RPENERGYB = 0x8A;  // B Forward Reactive
+static const uint16_t ATM90E32_REGISTER_RPENERGYC = 0x8B;  // C Forward Reactive
+static const uint16_t ATM90E32_REGISTER_RNENERGYT = 0x8C;  // Total Reverse Reactive
+static const uint16_t ATM90E32_REGISTER_RNENERGYA = 0x8D;  // A Reverse Reactive
+static const uint16_t ATM90E32_REGISTER_RNENERGYB = 0x8E;  // B Reverse Reactive
+static const uint16_t ATM90E32_REGISTER_RNENERGYC = 0x8F;  // C Reverse Reactive
+
+static const uint16_t ATM90E32_REGISTER_SAENERGYT = 0x90;  // Total Apparent Energy
+static const uint16_t ATM90E32_REGISTER_SENERGYA = 0x91;   // A Apparent Energy
+static const uint16_t ATM90E32_REGISTER_SENERGYB = 0x92;   // B Apparent Energy
+static const uint16_t ATM90E32_REGISTER_SENERGYC = 0x93;   // C Apparent Energy
+
+/* FUNDAMENTAL / HARMONIC ENERGY REGISTERS */
+static const uint16_t ATM90E32_REGISTER_APENERGYTF = 0xA0;  // Total Forward Fund. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYAF = 0xA1;  // A Forward Fund. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYBF = 0xA2;  // B Forward Fund. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYCF = 0xA3;  // C Forward Fund. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYTF = 0xA4;  // Total Reverse Fund Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYAF = 0xA5;  // A Reverse Fund. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYBF = 0xA6;  // B Reverse Fund. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYCF = 0xA7;  // C Reverse Fund. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYTH = 0xA8;  // Total Forward Harm. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYAH = 0xA9;  // A Forward Harm. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYBH = 0xAA;  // B Forward Harm. Energy
+static const uint16_t ATM90E32_REGISTER_APENERGYCH = 0xAB;  // C Forward Harm. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYTH = 0xAC;  // Total Reverse Harm. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYAH = 0xAD;  // A Reverse Harm. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYBH = 0xAE;  // B Reverse Harm. Energy
+static const uint16_t ATM90E32_REGISTER_ANENERGYCH = 0xAF;  // C Reverse Harm. Energy
+
+/* POWER & P.F. REGISTERS */
+static const uint16_t ATM90E32_REGISTER_PMEANT = 0xB0;   // Total Mean Power (P)
+static const uint16_t ATM90E32_REGISTER_PMEANA = 0xB1;   // A Mean Power (P)
+static const uint16_t ATM90E32_REGISTER_PMEANB = 0xB2;   // B Mean Power (P)
+static const uint16_t ATM90E32_REGISTER_PMEANC = 0xB3;   // C Mean Power (P)
+static const uint16_t ATM90E32_REGISTER_QMEANT = 0xB4;   // Total Mean Power (Q)
+static const uint16_t ATM90E32_REGISTER_QMEANA = 0xB5;   // A Mean Power (Q)
+static const uint16_t ATM90E32_REGISTER_QMEANB = 0xB6;   // B Mean Power (Q)
+static const uint16_t ATM90E32_REGISTER_QMEANC = 0xB7;   // C Mean Power (Q)
+static const uint16_t ATM90E32_REGISTER_SMEANT = 0xB8;   // Total Mean Power (S)
+static const uint16_t ATM90E32_REGISTER_SMEANA = 0xB9;   // A Mean Power (S)
+static const uint16_t ATM90E32_REGISTER_SMEANB = 0xBA;   // B Mean Power (S)
+static const uint16_t ATM90E32_REGISTER_SMEANC = 0xBB;   // C Mean Power (S)
+static const uint16_t ATM90E32_REGISTER_PFMEANT = 0xBC;  // Mean Power Factor
+static const uint16_t ATM90E32_REGISTER_PFMEANA = 0xBD;  // A Power Factor
+static const uint16_t ATM90E32_REGISTER_PFMEANB = 0xBE;  // B Power Factor
+static const uint16_t ATM90E32_REGISTER_PFMEANC = 0xBF;  // C Power Factor
+
+static const uint16_t ATM90E32_REGISTER_PMEANTLSB = 0xC0;   // Lower Word (Tot. Act. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANALSB = 0xC1;   // Lower Word (A Act. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANBLSB = 0xC2;   // Lower Word (B Act. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANCLSB = 0xC3;   // Lower Word (C Act. Power)
+static const uint16_t ATM90E32_REGISTER_QMEANTLSB = 0xC4;   // Lower Word (Tot. React. Power)
+static const uint16_t ATM90E32_REGISTER_QMEANALSB = 0xC5;   // Lower Word (A React. Power)
+static const uint16_t ATM90E32_REGISTER_QMEANBLSB = 0xC6;   // Lower Word (B React. Power)
+static const uint16_t ATM90E32_REGISTER_QMEANCLSB = 0xC7;   // Lower Word (C React. Power)
+static const uint16_t ATM90E32_REGISTER_SAMEANTLSB = 0xC8;  // Lower Word (Tot. App. Power)
+static const uint16_t ATM90E32_REGISTER_SMEANALSB = 0xC9;   // Lower Word (A App. Power)
+static const uint16_t ATM90E32_REGISTER_SMEANBLSB = 0xCA;   // Lower Word (B App. Power)
+static const uint16_t ATM90E32_REGISTER_SMEANCLSB = 0xCB;   // Lower Word (C App. Power)
+
+/* FUND/HARM POWER & V/I RMS REGISTERS */
+static const uint16_t ATM90E32_REGISTER_PMEANTF = 0xD0;  // Total Active Fund. Power
+static const uint16_t ATM90E32_REGISTER_PMEANAF = 0xD1;  // A Active Fund. Power
+static const uint16_t ATM90E32_REGISTER_PMEANBF = 0xD2;  // B Active Fund. Power
+static const uint16_t ATM90E32_REGISTER_PMEANCF = 0xD3;  // C Active Fund. Power
+static const uint16_t ATM90E32_REGISTER_PMEANTH = 0xD4;  // Total Active Harm. Power
+static const uint16_t ATM90E32_REGISTER_PMEANAH = 0xD5;  // A Active Harm. Power
+static const uint16_t ATM90E32_REGISTER_PMEANBH = 0xD6;  // B Active Harm. Power
+static const uint16_t ATM90E32_REGISTER_PMEANCH = 0xD7;  // C Active Harm. Power
+static const uint16_t ATM90E32_REGISTER_URMSA = 0xD9;    // A RMS Voltage
+static const uint16_t ATM90E32_REGISTER_URMSB = 0xDA;    // B RMS Voltage
+static const uint16_t ATM90E32_REGISTER_URMSC = 0xDB;    // C RMS Voltage
+static const uint16_t ATM90E32_REGISTER_IRMSA = 0xDD;    // A RMS Current
+static const uint16_t ATM90E32_REGISTER_IRMSB = 0xDE;    // B RMS Current
+static const uint16_t ATM90E32_REGISTER_IRMSC = 0xDF;    // C RMS Current
+static const uint16_t ATM90E32_REGISTER_IRMSN = 0xD8;    // Calculated N RMS Current
+
+static const uint16_t ATM90E32_REGISTER_PMEANTFLSB = 0xE0;  // Lower Word (Tot. Act. Fund. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANAFLSB = 0xE1;  // Lower Word (A Act. Fund. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANBFLSB = 0xE2;  // Lower Word (B Act. Fund. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANCFLSB = 0xE3;  // Lower Word (C Act. Fund. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANTHLSB = 0xE4;  // Lower Word (Tot. Act. Harm. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANAHLSB = 0xE5;  // Lower Word (A Act. Harm. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANBHLSB = 0xE6;  // Lower Word (B Act. Harm. Power)
+static const uint16_t ATM90E32_REGISTER_PMEANCHLSB = 0xE7;  // Lower Word (C Act. Harm. Power)
+static const uint16_t ATM90E32_REGISTER_URMSALSB = 0xE9;    // Lower Word (A RMS Voltage)
+static const uint16_t ATM90E32_REGISTER_URMSBLSB = 0xEA;    // Lower Word (B RMS Voltage)
+static const uint16_t ATM90E32_REGISTER_URMSCLSB = 0xEB;    // Lower Word (C RMS Voltage)
+static const uint16_t ATM90E32_REGISTER_IRMSALSB = 0xED;    // Lower Word (A RMS Current)
+static const uint16_t ATM90E32_REGISTER_IRMSBLSB = 0xEE;    // Lower Word (B RMS Current)
+static const uint16_t ATM90E32_REGISTER_IRMSCLSB = 0xEF;    // Lower Word (C RMS Current)
+
+/* THD, FREQUENCY, ANGLE & TEMPTEMP REGISTERS*/
+static const uint16_t ATM90E32_REGISTER_UPEAKA = 0xF1;   // A Voltage Peak
+static const uint16_t ATM90E32_REGISTER_UPEAKB = 0xF2;   // B Voltage Peak
+static const uint16_t ATM90E32_REGISTER_UPEAKC = 0xF3;   // C Voltage Peak
+static const uint16_t ATM90E32_REGISTER_IPEAKA = 0xF5;   // A Current Peak
+static const uint16_t ATM90E32_REGISTER_IPEAKB = 0xF6;   // B Current Peak
+static const uint16_t ATM90E32_REGISTER_IPEAKC = 0xF7;   // C Current Peak
+static const uint16_t ATM90E32_REGISTER_FREQ = 0xF8;     // Frequency
+static const uint16_t ATM90E32_REGISTER_PANGLEA = 0xF9;  // A Mean Phase Angle
+static const uint16_t ATM90E32_REGISTER_PANGLEB = 0xFA;  // B Mean Phase Angle
+static const uint16_t ATM90E32_REGISTER_PANGLEC = 0xFB;  // C Mean Phase Angle
+static const uint16_t ATM90E32_REGISTER_TEMP = 0xFC;     // Measured Temperature
+static const uint16_t ATM90E32_REGISTER_UANGLEA = 0xFD;  // A Voltage Phase Angle
+static const uint16_t ATM90E32_REGISTER_UANGLEB = 0xFE;  // B Voltage Phase Angle
+static const uint16_t ATM90E32_REGISTER_UANGLEC = 0xFF;  // C Voltage Phase Angle
+
+}  // namespace atm90e32
+}  // namespace esphome

esphome/components/atm90e32/sensor.py

@@ -0,0 +1,177 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, spi
+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_EMPTY,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_TEMPERATURE,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_EMPTY,
+    ICON_LIGHTBULB,
+    ICON_CURRENT_AC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_HERTZ,
+    UNIT_VOLT,
+    UNIT_AMPERE,
+    UNIT_WATT,
+    UNIT_EMPTY,
+    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_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,
+}
+CURRENT_PHASES = {
+    "2": 2,
+    "3": 3,
+}
+PGA_GAINS = {
+    "1X": 0x0,
+    "2X": 0x15,
+    "4X": 0x2A,
+}
+
+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_EMPTY,
+            2,
+            DEVICE_CLASS_VOLTAGE,
+            STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_CURRENT): sensor.sensor_schema(
+            UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT
+        ),
+        cv.Optional(CONF_POWER): sensor.sensor_schema(
+            UNIT_WATT, ICON_EMPTY, 2, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+        ),
+        cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
+            UNIT_VOLT_AMPS_REACTIVE,
+            ICON_LIGHTBULB,
+            2,
+            DEVICE_CLASS_EMPTY,
+            STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_POWER_FACTOR): sensor.sensor_schema(
+            UNIT_EMPTY,
+            ICON_EMPTY,
+            2,
+            DEVICE_CLASS_POWER_FACTOR,
+            STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_FORWARD_ACTIVE_ENERGY): sensor.sensor_schema(
+            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+        ),
+        cv.Optional(CONF_REVERSE_ACTIVE_ENERGY): sensor.sensor_schema(
+            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+        ),
+        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,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_CHIP_TEMPERATURE): sensor.sensor_schema(
+                UNIT_CELSIUS,
+                ICON_EMPTY,
+                1,
+                DEVICE_CLASS_TEMPERATURE,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Required(CONF_LINE_FREQUENCY): cv.enum(LINE_FREQS, upper=True),
+            cv.Optional(CONF_CURRENT_PHASES, default="3"): cv.enum(
+                CURRENT_PHASES, upper=True
+            ),
+            cv.Optional(CONF_GAIN_PGA, default="2X"): cv.enum(PGA_GAINS, upper=True),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(spi.spi_device_schema())
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await spi.register_spi_device(var, config)
+
+    for i, phase in enumerate([CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]):
+        if phase not in config:
+            continue
+        conf = config[phase]
+        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 = await sensor.new_sensor(conf[CONF_VOLTAGE])
+            cg.add(var.set_voltage_sensor(i, sens))
+        if CONF_CURRENT in conf:
+            sens = await sensor.new_sensor(conf[CONF_CURRENT])
+            cg.add(var.set_current_sensor(i, sens))
+        if CONF_POWER in conf:
+            sens = await sensor.new_sensor(conf[CONF_POWER])
+            cg.add(var.set_power_sensor(i, sens))
+        if CONF_REACTIVE_POWER in conf:
+            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 = 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 = await sensor.new_sensor(config[CONF_FREQUENCY])
+        cg.add(var.set_freq_sensor(sens))
+    if CONF_CHIP_TEMPERATURE in config:
+        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]))
+    cg.add(var.set_pga_gain(config[CONF_GAIN_PGA]))

esphome/components/b_parasite/b_parasite.cpp

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

esphome/components/b_parasite/b_parasite.h

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

esphome/components/b_parasite/sensor.py

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

esphome/components/bang_bang/__init__.py

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

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -46,80 +46,91 @@ climate::ClimateTraits BangBangClimate::traits() {
   traits.set_supports_heat_mode(this->supports_heat_);
   traits.set_supports_two_point_target_temperature(true);
   traits.set_supports_away(this->supports_away_);
+  traits.set_supports_action(true);
   return traits;
 }
 void BangBangClimate::compute_state_() {
   if (this->mode != climate::CLIMATE_MODE_AUTO) {
-    // in non-auto mode
-    this->switch_to_mode_(this->mode);
+    // 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));
     return;
   }
-
-  // auto mode, compute target mode
   if (isnan(this->current_temperature) || isnan(this->target_temperature_low) || isnan(this->target_temperature_high)) {
-    // if any control values are nan, go to OFF (idle) mode
-    this->switch_to_mode_(climate::CLIMATE_MODE_OFF);
+    // if any control parameters are nan, go to OFF action (not IDLE!)
+    this->switch_to_action_(climate::CLIMATE_ACTION_OFF);
     return;
   }
   const bool too_cold = this->current_temperature < this->target_temperature_low;
   const bool too_hot = this->current_temperature > this->target_temperature_high;
 
-  climate::ClimateMode target_mode;
+  climate::ClimateAction target_action;
   if (too_cold) {
     // too cold -> enable heating if possible, else idle
     if (this->supports_heat_)
-      target_mode = climate::CLIMATE_MODE_HEAT;
+      target_action = climate::CLIMATE_ACTION_HEATING;
     else
-      target_mode = climate::CLIMATE_MODE_OFF;
+      target_action = climate::CLIMATE_ACTION_IDLE;
   } else if (too_hot) {
     // too hot -> enable cooling if possible, else idle
     if (this->supports_cool_)
-      target_mode = climate::CLIMATE_MODE_COOL;
+      target_action = climate::CLIMATE_ACTION_COOLING;
     else
-      target_mode = climate::CLIMATE_MODE_OFF;
+      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 mode
-      target_mode = climate::CLIMATE_MODE_OFF;
+      // if supports both ends, go to idle action
+      target_action = climate::CLIMATE_ACTION_IDLE;
     } else {
       // else use current mode and don't change (hysteresis)
-      target_mode = this->internal_mode_;
+      target_action = this->action;
     }
   }
 
-  this->switch_to_mode_(target_mode);
+  this->switch_to_action_(target_action);
 }
-void BangBangClimate::switch_to_mode_(climate::ClimateMode mode) {
-  if (mode == this->internal_mode_)
+void BangBangClimate::switch_to_action_(climate::ClimateAction 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)) {
+    // switching from OFF to IDLE or vice-versa
+    // these only have visual difference. OFF means user manually disabled,
+    // IDLE means it's in auto mode but value is in target range.
+    this->action = action;
+    this->publish_state();
+    return;
+  }
+
   if (this->prev_trigger_ != nullptr) {
-    this->prev_trigger_->stop();
+    this->prev_trigger_->stop_action();
     this->prev_trigger_ = nullptr;
   }
   Trigger<> *trig;
-  switch (mode) {
-    case climate::CLIMATE_MODE_OFF:
+  switch (action) {
+    case climate::CLIMATE_ACTION_OFF:
+    case climate::CLIMATE_ACTION_IDLE:
       trig = this->idle_trigger_;
       break;
-    case climate::CLIMATE_MODE_COOL:
+    case climate::CLIMATE_ACTION_COOLING:
       trig = this->cool_trigger_;
       break;
-    case climate::CLIMATE_MODE_HEAT:
+    case climate::CLIMATE_ACTION_HEATING:
       trig = this->heat_trigger_;
       break;
     default:
       trig = nullptr;
   }
-  if (trig != nullptr) {
-    // trig should never be null, but still check so that we don't crash
-    trig->trigger();
-    this->internal_mode_ = mode;
-    this->prev_trigger_ = trig;
-    this->publish_state();
-  }
+  assert(trig != nullptr);
+  trig->trigger();
+  this->action = action;
+  this->prev_trigger_ = trig;
+  this->publish_state();
 }
 void BangBangClimate::change_away_(bool away) {
   if (!away) {
@@ -146,6 +157,14 @@ Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger
 void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
 Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger_; }
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+void BangBangClimate::dump_config() {
+  LOG_CLIMATE("", "Bang Bang Climate", this);
+  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
+  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
+  ESP_LOGCONFIG(TAG, "  Supports AWAY mode: %s", YESNO(this->supports_away_));
+  ESP_LOGCONFIG(TAG, "  Default Target Temperature Low: %.1f°C", this->normal_config_.default_temperature_low);
+  ESP_LOGCONFIG(TAG, "  Default Target Temperature High: %.1f°C", this->normal_config_.default_temperature_high);
+}
 
 BangBangClimateTargetTempConfig::BangBangClimateTargetTempConfig() = default;
 BangBangClimateTargetTempConfig::BangBangClimateTargetTempConfig(float default_temperature_low,

esphome/components/bang_bang/bang_bang_climate.h

@@ -21,6 +21,7 @@ class BangBangClimate : public climate::Climate, public Component {
  public:
   BangBangClimate();
   void setup() override;
+  void dump_config() override;
 
   void set_sensor(sensor::Sensor *sensor);
   Trigger<> *get_idle_trigger() const;
@@ -43,7 +44,7 @@ class BangBangClimate : public climate::Climate, public Component {
   void compute_state_();
 
   /// Switch the climate device to the given climate mode.
-  void switch_to_mode_(climate::ClimateMode mode);
+  void switch_to_action_(climate::ClimateAction action);
 
   /// The sensor used for getting the current temperature
   sensor::Sensor *sensor_{nullptr};
@@ -74,11 +75,6 @@ class BangBangClimate : public climate::Climate, public Component {
    * This is so that the previous trigger can be stopped before enabling a new one.
    */
   Trigger<> *prev_trigger_{nullptr};
-  /** The climate mode that is currently active - for a `.mode = AUTO` this will
-   * contain the actual mode the device
-   *
-   */
-  climate::ClimateMode internal_mode_{climate::CLIMATE_MODE_OFF};
 
   BangBangClimateTargetTempConfig normal_config_{};
   bool supports_away_{false};

esphome/components/bang_bang/climate.py

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

esphome/components/bh1750/bh1750.cpp

@@ -7,6 +7,8 @@ namespace bh1750 {
 static const char *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
 
 void BH1750Sensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up BH1750 '%s'...", this->name_.c_str());
@@ -14,7 +16,13 @@ void BH1750Sensor::setup() {
     this->mark_failed();
     return;
   }
+
+  uint8_t mtreg_hi = (this->measurement_duration_ >> 5) & 0b111;
+  uint8_t mtreg_lo = (this->measurement_duration_ >> 0) & 0b11111;
+  this->write_bytes(BH1750_COMMAND_MT_REG_HI | mtreg_hi, nullptr, 0);
+  this->write_bytes(BH1750_COMMAND_MT_REG_LO | mtreg_lo, nullptr, 0);
 }
+
 void BH1750Sensor::dump_config() {
   LOG_SENSOR("", "BH1750", this);
   LOG_I2C_DEVICE(this);
@@ -59,6 +67,7 @@ void BH1750Sensor::update() {
 
   this->set_timeout("illuminance", wait, [this]() { this->read_data_(); });
 }
+
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
 void BH1750Sensor::read_data_() {
   uint16_t raw_value;
@@ -68,10 +77,12 @@ void BH1750Sensor::read_data_() {
   }
 
   float lx = float(raw_value) / 1.2f;
+  lx *= 69.0f / this->measurement_duration_;
   ESP_LOGD(TAG, "'%s': Got illuminance=%.1flx", this->get_name().c_str(), lx);
   this->publish_state(lx);
   this->status_clear_warning();
 }
+
 void BH1750Sensor::set_resolution(BH1750Resolution resolution) { this->resolution_ = resolution; }
 
 }  // namespace bh1750

esphome/components/bh1750/bh1750.h

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

esphome/components/bh1750/sensor.py

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

esphome/components/binary/__init__.py

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

esphome/components/binary/fan/__init__.py

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

esphome/components/binary/fan/binary_fan.cpp

@@ -11,9 +11,12 @@ void binary::BinaryFan::dump_config() {
   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);
+  auto traits = fan::FanTraits(this->oscillating_ != nullptr, false, this->direction_ != nullptr, 0);
   this->fan_->set_traits(traits);
   this->fan_->add_on_state_callback([this]() { this->next_update_ = true; });
 }
@@ -41,6 +44,16 @@ void BinaryFan::loop() {
     }
     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));
+  }
 }
 float BinaryFan::get_setup_priority() const { return setup_priority::DATA; }
 

esphome/components/binary/fan/binary_fan.h

@@ -16,11 +16,13 @@ class BinaryFan : public Component {
   void dump_config() override;
   float get_setup_priority() const override;
   void set_oscillating(output::BinaryOutput *oscillating) { this->oscillating_ = oscillating; }
+  void set_direction(output::BinaryOutput *direction) { this->direction_ = direction; }
 
  protected:
   fan::FanState *fan_;
   output::BinaryOutput *output_;
   output::BinaryOutput *oscillating_{nullptr};
+  output::BinaryOutput *direction_{nullptr};
   bool next_update_{true};
 };
 

esphome/components/binary/light/__init__.py

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

esphome/components/binary_sensor/__init__.py

@@ -3,136 +3,277 @@ import esphome.config_validation as cv
 from esphome import automation, core
 from esphome.automation import Condition, maybe_simple_id
 from esphome.components import mqtt
-from esphome.const import CONF_DEVICE_CLASS, CONF_FILTERS, \
-    CONF_ID, CONF_INTERNAL, CONF_INVALID_COOLDOWN, CONF_INVERTED, \
-    CONF_MAX_LENGTH, CONF_MIN_LENGTH, CONF_ON_CLICK, \
-    CONF_ON_DOUBLE_CLICK, CONF_ON_MULTI_CLICK, CONF_ON_PRESS, CONF_ON_RELEASE, CONF_ON_STATE, \
-    CONF_STATE, CONF_TIMING, CONF_TRIGGER_ID, CONF_FOR, CONF_NAME, CONF_MQTT_ID
-from esphome.core import CORE, coroutine, coroutine_with_priority
-from esphome.py_compat import string_types
+from esphome.const import (
+    CONF_DELAY,
+    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,
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BATTERY_CHARGING,
+    DEVICE_CLASS_COLD,
+    DEVICE_CLASS_CONNECTIVITY,
+    DEVICE_CLASS_DOOR,
+    DEVICE_CLASS_GARAGE_DOOR,
+    DEVICE_CLASS_GAS,
+    DEVICE_CLASS_HEAT,
+    DEVICE_CLASS_LIGHT,
+    DEVICE_CLASS_LOCK,
+    DEVICE_CLASS_MOISTURE,
+    DEVICE_CLASS_MOTION,
+    DEVICE_CLASS_MOVING,
+    DEVICE_CLASS_OCCUPANCY,
+    DEVICE_CLASS_OPENING,
+    DEVICE_CLASS_PLUG,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_PRESENCE,
+    DEVICE_CLASS_PROBLEM,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_VIBRATION,
+    DEVICE_CLASS_WINDOW,
+)
+from esphome.core import CORE, coroutine_with_priority
 from esphome.util import Registry
 
+CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
-    '', 'battery', 'cold', 'connectivity', 'door', 'garage_door', 'gas',
-    'heat', 'light', 'lock', 'moisture', 'motion', 'moving', 'occupancy',
-    'opening', 'plug', 'power', 'presence', 'problem', 'safety', 'smoke',
-    'sound', 'vibration', 'window'
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BATTERY_CHARGING,
+    DEVICE_CLASS_COLD,
+    DEVICE_CLASS_CONNECTIVITY,
+    DEVICE_CLASS_DOOR,
+    DEVICE_CLASS_GARAGE_DOOR,
+    DEVICE_CLASS_GAS,
+    DEVICE_CLASS_HEAT,
+    DEVICE_CLASS_LIGHT,
+    DEVICE_CLASS_LOCK,
+    DEVICE_CLASS_MOISTURE,
+    DEVICE_CLASS_MOTION,
+    DEVICE_CLASS_MOVING,
+    DEVICE_CLASS_OCCUPANCY,
+    DEVICE_CLASS_OPENING,
+    DEVICE_CLASS_PLUG,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_PRESENCE,
+    DEVICE_CLASS_PROBLEM,
+    DEVICE_CLASS_SAFETY,
+    DEVICE_CLASS_SMOKE,
+    DEVICE_CLASS_SOUND,
+    DEVICE_CLASS_VIBRATION,
+    DEVICE_CLASS_WINDOW,
 ]
 
 IS_PLATFORM_COMPONENT = True
 
-binary_sensor_ns = cg.esphome_ns.namespace('binary_sensor')
-BinarySensor = binary_sensor_ns.class_('BinarySensor', cg.Nameable)
-BinarySensorPtr = BinarySensor.operator('ptr')
+binary_sensor_ns = cg.esphome_ns.namespace("binary_sensor")
+BinarySensor = binary_sensor_ns.class_("BinarySensor", cg.Nameable)
+BinarySensorInitiallyOff = binary_sensor_ns.class_(
+    "BinarySensorInitiallyOff", BinarySensor
+)
+BinarySensorPtr = BinarySensor.operator("ptr")
 
 # Triggers
-PressTrigger = binary_sensor_ns.class_('PressTrigger', automation.Trigger.template())
-ReleaseTrigger = binary_sensor_ns.class_('ReleaseTrigger', automation.Trigger.template())
-ClickTrigger = binary_sensor_ns.class_('ClickTrigger', automation.Trigger.template())
-DoubleClickTrigger = binary_sensor_ns.class_('DoubleClickTrigger', automation.Trigger.template())
-MultiClickTrigger = binary_sensor_ns.class_('MultiClickTrigger', automation.Trigger.template(),
-                                            cg.Component)
-MultiClickTriggerEvent = binary_sensor_ns.struct('MultiClickTriggerEvent')
-StateTrigger = binary_sensor_ns.class_('StateTrigger', automation.Trigger.template(bool))
-BinarySensorPublishAction = binary_sensor_ns.class_('BinarySensorPublishAction', automation.Action)
+PressTrigger = binary_sensor_ns.class_("PressTrigger", automation.Trigger.template())
+ReleaseTrigger = binary_sensor_ns.class_(
+    "ReleaseTrigger", automation.Trigger.template()
+)
+ClickTrigger = binary_sensor_ns.class_("ClickTrigger", automation.Trigger.template())
+DoubleClickTrigger = binary_sensor_ns.class_(
+    "DoubleClickTrigger", automation.Trigger.template()
+)
+MultiClickTrigger = binary_sensor_ns.class_(
+    "MultiClickTrigger", automation.Trigger.template(), cg.Component
+)
+MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")
+StateTrigger = binary_sensor_ns.class_(
+    "StateTrigger", automation.Trigger.template(bool)
+)
+BinarySensorPublishAction = binary_sensor_ns.class_(
+    "BinarySensorPublishAction", automation.Action
+)
 
 # Condition
-BinarySensorCondition = binary_sensor_ns.class_('BinarySensorCondition', Condition)
+BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Condition)
 
 # Filters
-Filter = binary_sensor_ns.class_('Filter')
-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', DelayedOnFilter,
-                          cv.positive_time_period_milliseconds)
-def delayed_on_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_off', DelayedOffFilter, cv.positive_time_period_milliseconds)
-def delayed_off_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('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_)
+@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)
+    await cg.register_component(var, {})
+    return var
 
 
-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,
-})
+CONF_TIME_OFF = "time_off"
+CONF_TIME_ON = "time_on"
+
+DEFAULT_DELAY = "1s"
+DEFAULT_TIME_OFF = "100ms"
+DEFAULT_TIME_ON = "900ms"
+
+
+@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, string_types):
+    if not isinstance(value, str):
         return value
 
-    parts = value.lower().split(' ')
+    parts = value.lower().split(" ")
     if len(parts) != 5:
-        raise cv.Invalid("Multi click timing grammar consists of exactly 5 words, not {}"
-                         "".format(len(parts)))
+        raise cv.Invalid(
+            "Multi click timing grammar consists of exactly 5 words, not {}"
+            "".format(len(parts))
+        )
     try:
         state = cv.boolean(parts[0])
     except cv.Invalid:
-        raise cv.Invalid(u"First word must either be ON or OFF, not {}".format(parts[0]))
+        # pylint: disable=raise-missing-from
+        raise cv.Invalid("First word must either be ON or OFF, not {}".format(parts[0]))
 
-    if parts[1] != 'for':
-        raise cv.Invalid(u"Second word must be 'for', got {}".format(parts[1]))
+    if parts[1] != "for":
+        raise cv.Invalid("Second word must be 'for', got {}".format(parts[1]))
 
-    if parts[2] == 'at':
-        if parts[3] == 'least':
+    if parts[2] == "at":
+        if parts[3] == "least":
             key = CONF_MIN_LENGTH
-        elif parts[3] == 'most':
+        elif parts[3] == "most":
             key = CONF_MAX_LENGTH
         else:
-            raise cv.Invalid(u"Third word after at must either be 'least' or 'most', got {}"
-                             u"".format(parts[3]))
+            raise cv.Invalid(
+                "Third word after at must either be 'least' or 'most', got {}"
+                "".format(parts[3])
+            )
         try:
             length = cv.positive_time_period_milliseconds(parts[4])
         except cv.Invalid as err:
-            raise cv.Invalid(u"Multi Click Grammar Parsing length failed: {}".format(err))
-        return {
-            CONF_STATE: state,
-            key: str(length)
-        }
+            raise cv.Invalid(f"Multi Click Grammar Parsing length failed: {err}")
+        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:
         min_length = cv.positive_time_period_milliseconds(parts[2])
     except cv.Invalid as err:
-        raise cv.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
+        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")
 
     try:
         max_length = cv.positive_time_period_milliseconds(parts[4])
     except cv.Invalid as err:
-        raise cv.Invalid(u"Multi Click Grammar Parsing minimum length failed: {}".format(err))
+        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")
 
     return {
         CONF_STATE: state,
         CONF_MIN_LENGTH: str(min_length),
-        CONF_MAX_LENGTH: str(max_length)
+        CONF_MAX_LENGTH: str(max_length),
     }
 
 
@@ -152,11 +293,15 @@ def validate_multi_click_timing(value):
 
         new_state = v_.get(CONF_STATE, not state)
         if new_state == state:
-            raise cv.Invalid("Timings must have alternating state. Indices {} and {} have "
-                             "the same state {}".format(i, i + 1, state))
+            raise cv.Invalid(
+                "Timings must have alternating state. Indices {} and {} have "
+                "the same state {}".format(i, i + 1, state)
+            )
         if max_length is not None and max_length < min_length:
-            raise cv.Invalid("Max length ({}) must be larger than min length ({})."
-                             "".format(max_length, min_length))
+            raise cv.Invalid(
+                "Max length ({}) must be larger than min length ({})."
+                "".format(max_length, min_length)
+            )
 
         state = new_state
         tim = {
@@ -169,140 +314,172 @@ def validate_multi_click_timing(value):
     return timings
 
 
-device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space='_')
+device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BinarySensor),
-    cv.OnlyWith(CONF_MQTT_ID, 'mqtt'): cv.declare_id(mqtt.MQTTBinarySensorComponent),
-
-    cv.Optional(CONF_DEVICE_CLASS): device_class,
-    cv.Optional(CONF_FILTERS): validate_filters,
-    cv.Optional(CONF_ON_PRESS): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PressTrigger),
-    }),
-    cv.Optional(CONF_ON_RELEASE): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ReleaseTrigger),
-    }),
-    cv.Optional(CONF_ON_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ClickTrigger),
-        cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_DOUBLE_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DoubleClickTrigger),
-        cv.Optional(CONF_MIN_LENGTH, default='50ms'): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_MAX_LENGTH, default='350ms'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_MULTI_CLICK): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(MultiClickTrigger),
-        cv.Required(CONF_TIMING): cv.All([parse_multi_click_timing_str],
-                                         validate_multi_click_timing),
-        cv.Optional(CONF_INVALID_COOLDOWN, default='1s'): cv.positive_time_period_milliseconds,
-    }),
-    cv.Optional(CONF_ON_STATE): automation.validate_automation({
-        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
-    }),
-
-    cv.Optional(CONF_INVERTED): cv.invalid(
-        "The inverted binary_sensor property has been replaced by the "
-        "new 'invert' binary  sensor filter. Please see "
-        "https://esphome.io/components/binary_sensor/index.html."
-    ),
-})
+BINARY_SENSOR_SCHEMA = cv.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."
+        ),
+    }
+)
 
 
-@coroutine
-def setup_binary_sensor_core_(var, config):
+async 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(CONF_INTERNAL))
+        cg.add(var.set_internal(config[CONF_INTERNAL]))
     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):
+async def new_binary_sensor(config):
     var = cg.new_Pvariable(config[CONF_ID], config[CONF_NAME])
-    yield register_binary_sensor(var, config)
-    yield var
+    await register_binary_sensor(var, config)
+    return var
 
 
-BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id({
-    cv.Required(CONF_ID): cv.use_id(BinarySensor),
-    cv.Optional(CONF_FOR): cv.invalid("This option has been removed in 1.13, please use the "
-                                      "'for' condition instead."),
-})
+BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(BinarySensor),
+        cv.Optional(CONF_FOR): cv.invalid(
+            "This option has been removed in 1.13, please use the "
+            "'for' condition instead."
+        ),
+    }
+)
 
 
-@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.h

@@ -137,6 +137,7 @@ template<typename... Ts> class BinarySensorPublishAction : public Action<Ts...>
  public:
   explicit BinarySensorPublishAction(BinarySensor *sensor) : sensor_(sensor) {}
   TEMPLATABLE_VALUE(bool, state)
+
   void play(Ts... x) override {
     auto val = this->state_.value(x...);
     this->sensor_->publish_state(val);

esphome/components/binary_sensor/binary_sensor.cpp

@@ -30,7 +30,11 @@ void BinarySensor::publish_initial_state(bool state) {
   }
 }
 void BinarySensor::send_state_internal(bool state, bool is_initial) {
-  ESP_LOGD(TAG, "'%s': Sending state %s", this->get_name().c_str(), state ? "ON" : "OFF");
+  if (is_initial) {
+    ESP_LOGD(TAG, "'%s': Sending initial state %s", this->get_name().c_str(), ONOFF(state));
+  } else {
+    ESP_LOGD(TAG, "'%s': Sending state %s", this->get_name().c_str(), ONOFF(state));
+  }
   this->has_state_ = true;
   this->state = state;
   if (!is_initial) {

esphome/components/binary_sensor/binary_sensor.h

@@ -10,9 +10,9 @@ namespace binary_sensor {
 
 #define LOG_BINARY_SENSOR(prefix, type, obj) \
   if (obj != nullptr) { \
-    ESP_LOGCONFIG(TAG, prefix type " '%s'", obj->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, obj->get_name().c_str()); \
     if (!obj->get_device_class().empty()) { \
-      ESP_LOGCONFIG(TAG, prefix "  Device Class: '%s'", obj->get_device_class().c_str()); \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, obj->get_device_class().c_str()); \
     } \
   }
 
@@ -67,7 +67,7 @@ class BinarySensor : public Nameable {
   void send_state_internal(bool state, bool is_initial);
 
   /// Return whether this binary sensor has outputted a state.
-  bool has_state() const;
+  virtual bool has_state() const;
 
   virtual bool is_status_binary_sensor() const;
 
@@ -86,5 +86,10 @@ class BinarySensor : public Nameable {
   Deduplicator<bool> publish_dedup_;
 };
 
+class BinarySensorInitiallyOff : public BinarySensor {
+ public:
+  bool has_state() const override { return true; }
+};
+
 }  // namespace binary_sensor
 }  // namespace esphome

esphome/components/binary_sensor/filter.cpp

@@ -23,6 +23,19 @@ void Filter::input(bool value, bool is_initial) {
     this->output(*b, is_initial);
   }
 }
+
+DelayedOnOffFilter::DelayedOnOffFilter(uint32_t delay) : delay_(delay) {}
+optional<bool> DelayedOnOffFilter::new_value(bool value, bool is_initial) {
+  if (value) {
+    this->set_timeout("ON_OFF", this->delay_, [this, is_initial]() { this->output(true, is_initial); });
+  } else {
+    this->set_timeout("ON_OFF", this->delay_, [this, is_initial]() { this->output(false, is_initial); });
+  }
+  return {};
+}
+
+float DelayedOnOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
+
 DelayedOnFilter::DelayedOnFilter(uint32_t delay) : delay_(delay) {}
 optional<bool> DelayedOnFilter::new_value(bool value, bool is_initial) {
   if (value) {
@@ -46,10 +59,55 @@ optional<bool> DelayedOffFilter::new_value(bool value, bool is_initial) {
     return true;
   }
 }
+
 float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 optional<bool> InvertFilter::new_value(bool value, bool is_initial) { return !value; }
 
+AutorepeatFilter::AutorepeatFilter(const std::vector<AutorepeatFilterTiming> &timings) : timings_(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(const std::function<optional<bool>(bool)> &f) : f_(f) {}
 
 optional<bool> LambdaFilter::new_value(bool value, bool is_initial) { return this->f_(value); }

esphome/components/binary_sensor/filter.h

@@ -25,6 +25,18 @@ class Filter {
   Deduplicator<bool> dedup_;
 };
 
+class DelayedOnOffFilter : public Filter, public Component {
+ public:
+  explicit DelayedOnOffFilter(uint32_t delay);
+
+  optional<bool> new_value(bool value, bool is_initial) override;
+
+  float get_setup_priority() const override;
+
+ protected:
+  uint32_t delay_;
+};
+
 class DelayedOnFilter : public Filter, public Component {
  public:
   explicit DelayedOnFilter(uint32_t delay);
@@ -54,6 +66,33 @@ 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(const 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);

esphome/components/binary_sensor_map/sensor.py

@@ -2,16 +2,27 @@ 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
+from esphome.const import (
+    CONF_ID,
+    CONF_CHANNELS,
+    CONF_VALUE,
+    CONF_TYPE,
+    DEVICE_CLASS_EMPTY,
+    UNIT_EMPTY,
+    ICON_CHECK_CIRCLE_OUTLINE,
+    CONF_BINARY_SENSOR,
+    CONF_GROUP,
+    STATE_CLASS_NONE,
+)
 
-DEPENDENCIES = ['binary_sensor']
+DEPENDENCIES = ["binary_sensor"]
 
-binary_sensor_map_ns = cg.esphome_ns.namespace('binary_sensor_map')
-BinarySensorMap = binary_sensor_map_ns.class_('BinarySensorMap', cg.Component, sensor.Sensor)
-SensorMapType = binary_sensor_map_ns.enum('SensorMapType')
+binary_sensor_map_ns = cg.esphome_ns.namespace("binary_sensor_map")
+BinarySensorMap = binary_sensor_map_ns.class_(
+    "BinarySensorMap", cg.Component, sensor.Sensor
+)
+SensorMapType = binary_sensor_map_ns.enum("SensorMapType")
 
-CONF_GROUP = 'group'
 SENSOR_MAP_TYPES = {
     CONF_GROUP: SensorMapType.BINARY_SENSOR_MAP_TYPE_GROUP,
 }
@@ -21,22 +32,35 @@ 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(
+            UNIT_EMPTY,
+            ICON_CHECK_CIRCLE_OUTLINE,
+            0,
+            DEVICE_CLASS_EMPTY,
+            STATE_CLASS_NONE,
+        ).extend(
+            {
+                cv.GenerateID(): cv.declare_id(BinarySensorMap),
+                cv.Required(CONF_CHANNELS): cv.All(
+                    cv.ensure_list(entry), cv.Length(min=1)
+                ),
+            }
+        ),
+    },
+    lower=True,
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
+    await sensor.register_sensor(var, config)
 
     constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
     cg.add(var.set_sensor_type(constant))
 
     for ch in config[CONF_CHANNELS]:
-        input_var = yield cg.get_variable(ch[CONF_BINARY_SENSOR])
+        input_var = await cg.get_variable(ch[CONF_BINARY_SENSOR])
         cg.add(var.add_channel(input_var, ch[CONF_VALUE]))

esphome/components/ble_client/__init__.py

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

esphome/components/ble_client/automation.h

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

esphome/components/ble_client/ble_client.cpp

@@ -0,0 +1,392 @@
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "ble_client.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *TAG = "ble_client";
+
+void BLEClient::setup() {
+  auto ret = esp_ble_gattc_app_register(this->app_id);
+  if (ret) {
+    ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
+    this->mark_failed();
+  }
+  this->set_states(espbt::ClientState::Idle);
+  this->enabled = true;
+}
+
+void BLEClient::loop() {
+  if (this->state() == espbt::ClientState::Discovered) {
+    this->connect();
+  }
+  for (auto *node : this->nodes_)
+    node->loop();
+}
+
+void BLEClient::dump_config() {
+  ESP_LOGCONFIG(TAG, "BLE Client:");
+  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
+}
+
+bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
+  if (!this->enabled)
+    return false;
+  if (device.address_uint64() != this->address)
+    return false;
+  if (this->state() != espbt::ClientState::Idle)
+    return false;
+
+  ESP_LOGD(TAG, "Found device at MAC address [%s]", device.address_str().c_str());
+  this->set_states(espbt::ClientState::Discovered);
+
+  auto addr = device.address_uint64();
+  this->remote_bda[0] = (addr >> 40) & 0xFF;
+  this->remote_bda[1] = (addr >> 32) & 0xFF;
+  this->remote_bda[2] = (addr >> 24) & 0xFF;
+  this->remote_bda[3] = (addr >> 16) & 0xFF;
+  this->remote_bda[4] = (addr >> 8) & 0xFF;
+  this->remote_bda[5] = (addr >> 0) & 0xFF;
+  return true;
+}
+
+std::string BLEClient::address_str() const {
+  char buf[20];
+  sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x", (uint8_t)(this->address >> 40) & 0xff,
+          (uint8_t)(this->address >> 32) & 0xff, (uint8_t)(this->address >> 24) & 0xff,
+          (uint8_t)(this->address >> 16) & 0xff, (uint8_t)(this->address >> 8) & 0xff,
+          (uint8_t)(this->address >> 0) & 0xff);
+  std::string ret;
+  ret = buf;
+  return ret;
+}
+
+void BLEClient::set_enabled(bool enabled) {
+  if (enabled == this->enabled)
+    return;
+  if (!enabled && this->state() != espbt::ClientState::Idle) {
+    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str());
+    auto ret = esp_ble_gattc_close(this->gattc_if, this->conn_id);
+    if (ret) {
+      ESP_LOGW(TAG, "esp_ble_gattc_close error, address=%s status=%d", this->address_str().c_str(), ret);
+    }
+  }
+  this->enabled = enabled;
+}
+
+void BLEClient::connect() {
+  ESP_LOGI(TAG, "Attempting BLE connection to %s", this->address_str().c_str());
+  auto ret = esp_ble_gattc_open(this->gattc_if, this->remote_bda, BLE_ADDR_TYPE_PUBLIC, true);
+  if (ret) {
+    ESP_LOGW(TAG, "esp_ble_gattc_open error, address=%s status=%d", this->address_str().c_str(), ret);
+    this->set_states(espbt::ClientState::Idle);
+  } else {
+    this->set_states(espbt::ClientState::Connecting);
+  }
+}
+
+void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
+                                    esp_ble_gattc_cb_param_t *param) {
+  if (event == ESP_GATTC_REG_EVT && this->app_id != param->reg.app_id)
+    return;
+  if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if)
+    return;
+
+  bool all_established = this->all_nodes_established();
+
+  switch (event) {
+    case ESP_GATTC_REG_EVT: {
+      if (param->reg.status == ESP_GATT_OK) {
+        ESP_LOGV(TAG, "gattc registered app id %d", this->app_id);
+        this->gattc_if = esp_gattc_if;
+      } else {
+        ESP_LOGE(TAG, "gattc app registration failed id=%d code=%d", param->reg.app_id, param->reg.status);
+      }
+      break;
+    }
+    case ESP_GATTC_OPEN_EVT: {
+      ESP_LOGV(TAG, "[%s] ESP_GATTC_OPEN_EVT", this->address_str().c_str());
+      if (param->open.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "connect to %s failed, status=%d", this->address_str().c_str(), param->open.status);
+        this->set_states(espbt::ClientState::Idle);
+        break;
+      }
+      this->conn_id = param->open.conn_id;
+      auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if, param->open.conn_id);
+      if (ret) {
+        ESP_LOGW(TAG, "esp_ble_gattc_send_mtu_req failed, status=%d", ret);
+      }
+      break;
+    }
+    case ESP_GATTC_CFG_MTU_EVT: {
+      if (param->cfg_mtu.status != ESP_GATT_OK) {
+        ESP_LOGW(TAG, "cfg_mtu to %s failed, status %d", this->address_str().c_str(), param->cfg_mtu.status);
+        this->set_states(espbt::ClientState::Idle);
+        break;
+      }
+      ESP_LOGV(TAG, "cfg_mtu status %d, mtu %d", param->cfg_mtu.status, param->cfg_mtu.mtu);
+      esp_ble_gattc_search_service(esp_gattc_if, param->cfg_mtu.conn_id, NULL);
+      break;
+    }
+    case ESP_GATTC_DISCONNECT_EVT: {
+      if (memcmp(param->disconnect.remote_bda, this->remote_bda, 6) != 0) {
+        return;
+      }
+      ESP_LOGV(TAG, "[%s] ESP_GATTC_DISCONNECT_EVT", this->address_str().c_str());
+      for (auto &svc : this->services_)
+        delete svc;
+      this->services_.clear();
+      this->set_states(espbt::ClientState::Idle);
+      break;
+    }
+    case ESP_GATTC_SEARCH_RES_EVT: {
+      BLEService *ble_service = new BLEService();
+      ble_service->uuid = espbt::ESPBTUUID::from_uuid(param->search_res.srvc_id.uuid);
+      ble_service->start_handle = param->search_res.start_handle;
+      ble_service->end_handle = param->search_res.end_handle;
+      ble_service->client = this;
+      this->services_.push_back(ble_service);
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      ESP_LOGV(TAG, "[%s] ESP_GATTC_SEARCH_CMPL_EVT", this->address_str().c_str());
+      for (auto &svc : this->services_) {
+        ESP_LOGI(TAG, "Service UUID: %s", svc->uuid.to_string().c_str());
+        ESP_LOGI(TAG, "  start_handle: 0x%x  end_handle: 0x%x", svc->start_handle, svc->end_handle);
+        svc->parse_characteristics();
+      }
+      this->set_states(espbt::ClientState::Connected);
+      this->set_state(espbt::ClientState::Established);
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      auto descr = this->get_config_descriptor(param->reg_for_notify.handle);
+      if (descr == nullptr) {
+        ESP_LOGW(TAG, "No descriptor found for notify of handle 0x%x", param->reg_for_notify.handle);
+        break;
+      }
+      if (descr->uuid.get_uuid().len != ESP_UUID_LEN_16 ||
+          descr->uuid.get_uuid().uuid.uuid16 != ESP_GATT_UUID_CHAR_CLIENT_CONFIG) {
+        ESP_LOGW(TAG, "Handle 0x%x (uuid %s) is not a client config char uuid", param->reg_for_notify.handle,
+                 descr->uuid.to_string().c_str());
+        break;
+      }
+      uint8_t notify_en = 1;
+      auto status = esp_ble_gattc_write_char_descr(this->gattc_if, this->conn_id, descr->handle, sizeof(notify_en),
+                                                   &notify_en, ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
+      if (status) {
+        ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
+  for (auto *node : this->nodes_)
+    node->gattc_event_handler(event, esp_gattc_if, param);
+
+  // Delete characteristics after clients have used them to save RAM.
+  if (!all_established && this->all_nodes_established()) {
+    for (auto &svc : this->services_)
+      delete svc;
+    this->services_.clear();
+  }
+}
+
+// Parse GATT values into a float for a sensor.
+// Ref: https://www.bluetooth.com/specifications/assigned-numbers/format-types/
+float BLEClient::parse_char_value(uint8_t *value, uint16_t length) {
+  // A length of one means a single octet value.
+  if (length == 0)
+    return 0;
+  if (length == 1)
+    return (float) ((uint8_t) value[0]);
+
+  switch (value[0]) {
+    case 0x1:  // boolean.
+    case 0x2:  // 2bit.
+    case 0x3:  // nibble.
+    case 0x4:  // uint8.
+      return (float) ((uint8_t) value[1]);
+    case 0x5:  // uint12.
+    case 0x6:  // uint16.
+      if (length > 2) {
+        return (float) ((uint16_t)(value[1] << 8) + (uint16_t) value[2]);
+      }
+    case 0x7:  // uint24.
+      if (length > 3) {
+        return (float) ((uint32_t)(value[1] << 16) + (uint32_t)(value[2] << 8) + (uint32_t)(value[3]));
+      }
+    case 0x8:  // uint32.
+      if (length > 4) {
+        return (float) ((uint32_t)(value[1] << 24) + (uint32_t)(value[2] << 16) + (uint32_t)(value[3] << 8) +
+                        (uint32_t)(value[4]));
+      }
+    case 0xC:  // int8.
+      return (float) ((int8_t) value[1]);
+    case 0xD:  // int12.
+    case 0xE:  // int16.
+      if (length > 2) {
+        return (float) ((int16_t)(value[1] << 8) + (int16_t) value[2]);
+      }
+    case 0xF:  // int24.
+      if (length > 3) {
+        return (float) ((int32_t)(value[1] << 16) + (int32_t)(value[2] << 8) + (int32_t)(value[3]));
+      }
+    case 0x10:  // int32.
+      if (length > 4) {
+        return (float) ((int32_t)(value[1] << 24) + (int32_t)(value[2] << 16) + (int32_t)(value[3] << 8) +
+                        (int32_t)(value[4]));
+      }
+  }
+  ESP_LOGW(TAG, "Cannot parse characteristic value of type 0x%x length %d", value[0], length);
+  return NAN;
+}
+
+BLEService *BLEClient::get_service(espbt::ESPBTUUID uuid) {
+  for (auto svc : this->services_)
+    if (svc->uuid == uuid)
+      return svc;
+  return nullptr;
+}
+
+BLEService *BLEClient::get_service(uint16_t uuid) { return this->get_service(espbt::ESPBTUUID::from_uint16(uuid)); }
+
+BLECharacteristic *BLEClient::get_characteristic(espbt::ESPBTUUID service, espbt::ESPBTUUID chr) {
+  auto svc = this->get_service(service);
+  if (svc == nullptr)
+    return nullptr;
+  return svc->get_characteristic(chr);
+}
+
+BLECharacteristic *BLEClient::get_characteristic(uint16_t service, uint16_t chr) {
+  return this->get_characteristic(espbt::ESPBTUUID::from_uint16(service), espbt::ESPBTUUID::from_uint16(chr));
+}
+
+BLEDescriptor *BLEClient::get_config_descriptor(uint16_t handle) {
+  for (auto &svc : this->services_)
+    for (auto &chr : svc->characteristics)
+      if (chr->handle == handle)
+        for (auto &desc : chr->descriptors)
+          if (desc->uuid == espbt::ESPBTUUID::from_uint16(0x2902))
+            return desc;
+  return nullptr;
+}
+
+BLECharacteristic *BLEService::get_characteristic(espbt::ESPBTUUID uuid) {
+  for (auto &chr : this->characteristics)
+    if (chr->uuid == uuid)
+      return chr;
+  return nullptr;
+}
+
+BLECharacteristic *BLEService::get_characteristic(uint16_t uuid) {
+  return this->get_characteristic(espbt::ESPBTUUID::from_uint16(uuid));
+}
+
+BLEDescriptor *BLEClient::get_descriptor(espbt::ESPBTUUID service, espbt::ESPBTUUID chr, espbt::ESPBTUUID descr) {
+  auto svc = this->get_service(service);
+  if (svc == nullptr)
+    return nullptr;
+  auto ch = svc->get_characteristic(chr);
+  if (ch == nullptr)
+    return nullptr;
+  return ch->get_descriptor(descr);
+}
+
+BLEDescriptor *BLEClient::get_descriptor(uint16_t service, uint16_t chr, uint16_t descr) {
+  return this->get_descriptor(espbt::ESPBTUUID::from_uint16(service), espbt::ESPBTUUID::from_uint16(chr),
+                              espbt::ESPBTUUID::from_uint16(descr));
+}
+
+BLEService::~BLEService() {
+  for (auto &chr : this->characteristics)
+    delete chr;
+}
+
+void BLEService::parse_characteristics() {
+  uint16_t offset = 0;
+  esp_gattc_char_elem_t result;
+
+  while (true) {
+    uint16_t count = 1;
+    esp_gatt_status_t status = esp_ble_gattc_get_all_char(
+        this->client->gattc_if, this->client->conn_id, this->start_handle, this->end_handle, &result, &count, offset);
+    if (status == ESP_GATT_INVALID_OFFSET || status == ESP_GATT_NOT_FOUND) {
+      break;
+    }
+    if (status != ESP_GATT_OK) {
+      ESP_LOGW(TAG, "esp_ble_gattc_get_all_char error, status=%d", status);
+      break;
+    }
+    if (count == 0) {
+      break;
+    }
+
+    BLECharacteristic *characteristic = new BLECharacteristic();
+    characteristic->uuid = espbt::ESPBTUUID::from_uuid(result.uuid);
+    characteristic->properties = result.properties;
+    characteristic->handle = result.char_handle;
+    characteristic->service = this;
+    this->characteristics.push_back(characteristic);
+    ESP_LOGI(TAG, " characteristic %s, handle 0x%x, properties 0x%x", characteristic->uuid.to_string().c_str(),
+             characteristic->handle, characteristic->properties);
+    characteristic->parse_descriptors();
+    offset++;
+  }
+}
+
+BLECharacteristic::~BLECharacteristic() {
+  for (auto &desc : this->descriptors)
+    delete desc;
+}
+
+void BLECharacteristic::parse_descriptors() {
+  uint16_t offset = 0;
+  esp_gattc_descr_elem_t result;
+
+  while (true) {
+    uint16_t count = 1;
+    esp_gatt_status_t status = esp_ble_gattc_get_all_descr(
+        this->service->client->gattc_if, this->service->client->conn_id, this->handle, &result, &count, offset);
+    if (status == ESP_GATT_INVALID_OFFSET || status == ESP_GATT_NOT_FOUND) {
+      break;
+    }
+    if (status != ESP_GATT_OK) {
+      ESP_LOGW(TAG, "esp_ble_gattc_get_all_descr error, status=%d", status);
+      break;
+    }
+    if (count == 0) {
+      break;
+    }
+
+    BLEDescriptor *desc = new BLEDescriptor();
+    desc->uuid = espbt::ESPBTUUID::from_uuid(result.uuid);
+    desc->handle = result.handle;
+    desc->characteristic = this;
+    this->descriptors.push_back(desc);
+    ESP_LOGV(TAG, "   descriptor %s, handle 0x%x", desc->uuid.to_string().c_str(), desc->handle);
+    offset++;
+  }
+}
+
+BLEDescriptor *BLECharacteristic::get_descriptor(espbt::ESPBTUUID uuid) {
+  for (auto &desc : this->descriptors)
+    if (desc->uuid == uuid)
+      return desc;
+  return nullptr;
+}
+BLEDescriptor *BLECharacteristic::get_descriptor(uint16_t uuid) {
+  return this->get_descriptor(espbt::ESPBTUUID::from_uint16(uuid));
+}
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/ble_client.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <string>
+#include <array>
+#include <esp_gap_ble_api.h>
+#include <esp_gattc_api.h>
+#include <esp_bt_defs.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class BLEClient;
+class BLEService;
+class BLECharacteristic;
+
+class BLEClientNode {
+ public:
+  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                   esp_ble_gattc_cb_param_t *param) = 0;
+  virtual void loop() = 0;
+  void set_address(uint64_t address) { address_ = address; }
+  espbt::ESPBTClient *client;
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  espbt::ClientState node_state;
+
+  BLEClient *parent() { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_;
+  uint64_t address_;
+};
+
+class BLEDescriptor {
+ public:
+  espbt::ESPBTUUID uuid;
+  uint16_t handle;
+
+  BLECharacteristic *characteristic;
+};
+
+class BLECharacteristic {
+ public:
+  ~BLECharacteristic();
+  espbt::ESPBTUUID uuid;
+  uint16_t handle;
+  esp_gatt_char_prop_t properties;
+  std::vector<BLEDescriptor *> descriptors;
+  void parse_descriptors();
+  BLEDescriptor *get_descriptor(espbt::ESPBTUUID uuid);
+  BLEDescriptor *get_descriptor(uint16_t uuid);
+
+  BLEService *service;
+};
+
+class BLEService {
+ public:
+  ~BLEService();
+  espbt::ESPBTUUID uuid;
+  uint16_t start_handle;
+  uint16_t end_handle;
+  std::vector<BLECharacteristic *> characteristics;
+  BLEClient *client;
+  void parse_characteristics();
+  BLECharacteristic *get_characteristic(espbt::ESPBTUUID uuid);
+  BLECharacteristic *get_characteristic(uint16_t uuid);
+};
+
+class BLEClient : public espbt::ESPBTClient, public Component {
+ public:
+  void setup() override;
+  void dump_config() override;
+  void loop() override;
+
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
+  bool parse_device(const espbt::ESPBTDevice &device) override;
+  void on_scan_end() override {}
+  void connect();
+
+  void set_address(uint64_t address) { this->address = address; }
+
+  void set_enabled(bool enabled);
+
+  void register_ble_node(BLEClientNode *node) {
+    node->client = this;
+    node->set_ble_client_parent(this);
+    this->nodes_.push_back(node);
+  }
+
+  BLEService *get_service(espbt::ESPBTUUID uuid);
+  BLEService *get_service(uint16_t uuid);
+  BLECharacteristic *get_characteristic(espbt::ESPBTUUID service, espbt::ESPBTUUID chr);
+  BLECharacteristic *get_characteristic(uint16_t service, uint16_t chr);
+  BLEDescriptor *get_descriptor(espbt::ESPBTUUID service, espbt::ESPBTUUID chr, espbt::ESPBTUUID descr);
+  BLEDescriptor *get_descriptor(uint16_t service, uint16_t chr, uint16_t descr);
+  // Get the configuration descriptor for the given characteristic handle.
+  BLEDescriptor *get_config_descriptor(uint16_t handle);
+
+  float parse_char_value(uint8_t *value, uint16_t length);
+
+  int gattc_if;
+  esp_bd_addr_t remote_bda;
+  uint16_t conn_id;
+  uint64_t address;
+  bool enabled;
+  std::string address_str() const;
+
+ protected:
+  void set_states(espbt::ClientState st) {
+    this->set_state(st);
+    for (auto &node : nodes_)
+      node->node_state = st;
+  }
+  bool all_nodes_established() {
+    if (this->state() != espbt::ClientState::Established)
+      return false;
+    for (auto &node : nodes_)
+      if (node->node_state != espbt::ClientState::Established)
+        return false;
+    return true;
+  }
+
+  std::vector<BLEClientNode *> nodes_;
+  std::vector<BLEService *> services_;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+
+#endif

esphome/components/ble_client/sensor/__init__.py

@@ -0,0 +1,129 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, ble_client, esp32_ble_tracker
+from esphome.const import (
+    DEVICE_CLASS_EMPTY,
+    CONF_ID,
+    CONF_LAMBDA,
+    STATE_CLASS_NONE,
+    UNIT_EMPTY,
+    ICON_EMPTY,
+    CONF_TRIGGER_ID,
+    CONF_SERVICE_UUID,
+)
+from esphome import automation
+from .. import ble_client_ns
+
+DEPENDENCIES = ["ble_client"]
+
+CONF_CHARACTERISTIC_UUID = "characteristic_uuid"
+CONF_DESCRIPTOR_UUID = "descriptor_uuid"
+
+CONF_NOTIFY = "notify"
+CONF_ON_NOTIFY = "on_notify"
+
+adv_data_t = cg.std_vector.template(cg.uint8)
+adv_data_t_const_ref = adv_data_t.operator("ref").operator("const")
+
+BLESensor = ble_client_ns.class_(
+    "BLESensor", sensor.Sensor, cg.PollingComponent, ble_client.BLEClientNode
+)
+BLESensorNotifyTrigger = ble_client_ns.class_(
+    "BLESensorNotifyTrigger", automation.Trigger.template(cg.float_)
+)
+
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY, STATE_CLASS_NONE
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLESensor),
+            cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+            cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
+            cv.Optional(CONF_DESCRIPTOR_UUID): esp32_ble_tracker.bt_uuid,
+            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+            cv.Optional(CONF_NOTIFY, default=False): cv.boolean,
+            cv.Optional(CONF_ON_NOTIFY): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLESensorNotifyTrigger
+                    ),
+                }
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(ble_client.BLE_CLIENT_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+        cg.add(
+            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+        uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_SERVICE_UUID])
+        cg.add(var.set_service_uuid128(uuid128))
+
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_char_uuid16(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid32_format
+    ):
+        cg.add(
+            var.set_char_uuid32(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid128_format
+    ):
+        uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_CHARACTERISTIC_UUID])
+        cg.add(var.set_char_uuid128(uuid128))
+
+    if CONF_DESCRIPTOR_UUID in config:
+        if len(config[CONF_DESCRIPTOR_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+            cg.add(
+                var.set_descr_uuid16(
+                    esp32_ble_tracker.as_hex(config[CONF_DESCRIPTOR_UUID])
+                )
+            )
+        elif len(config[CONF_DESCRIPTOR_UUID]) == len(
+            esp32_ble_tracker.bt_uuid32_format
+        ):
+            cg.add(
+                var.set_descr_uuid32(
+                    esp32_ble_tracker.as_hex(config[CONF_DESCRIPTOR_UUID])
+                )
+            )
+        elif len(config[CONF_DESCRIPTOR_UUID]) == len(
+            esp32_ble_tracker.bt_uuid128_format
+        ):
+            uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_DESCRIPTOR_UUID])
+            cg.add(var.set_descr_uuid128(uuid128))
+
+    if CONF_LAMBDA in config:
+        lambda_ = await cg.process_lambda(
+            config[CONF_LAMBDA], [(adv_data_t_const_ref, "x")], return_type=cg.float_
+        )
+        cg.add(var.set_data_to_value(lambda_))
+
+    await cg.register_component(var, config)
+    await ble_client.register_ble_node(var, config)
+    cg.add(var.set_enable_notify(config[CONF_NOTIFY]))
+    await sensor.register_sensor(var, config)
+    for conf in config.get(CONF_ON_NOTIFY, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await ble_client.register_ble_node(trigger, config)
+        await automation.build_automation(trigger, [(float, "x")], conf)

esphome/components/ble_client/sensor/automation.h

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

esphome/components/ble_client/sensor/ble_sensor.cpp

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

esphome/components/ble_client/sensor/ble_sensor.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/ble_client/ble_client.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/sensor/sensor.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+using data_to_value_t = std::function<float(std::vector<uint8_t>)>;
+
+class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClientNode {
+ public:
+  void loop() override;
+  void update() override;
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+  void set_descr_uuid16(uint16_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+  void set_data_to_value(data_to_value_t &&lambda_) { this->data_to_value_func_ = lambda_; }
+  void set_enable_notify(bool notify) { this->notify_ = notify; }
+  uint16_t handle;
+
+ protected:
+  uint32_t hash_base() override;
+  float parse_data(uint8_t *value, uint16_t value_len);
+  optional<data_to_value_t> data_to_value_func_{};
+  bool notify_;
+  espbt::ESPBTUUID service_uuid_;
+  espbt::ESPBTUUID char_uuid_;
+  espbt::ESPBTUUID descr_uuid_;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/switch/__init__.py

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

esphome/components/ble_client/switch/ble_switch.cpp

@@ -0,0 +1,39 @@
+#include "ble_switch.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_client {
+
+static const char *TAG = "ble_switch";
+
+void BLEClientSwitch::write_state(bool state) {
+  this->parent_->set_enabled(state);
+  this->publish_state(state);
+}
+
+void BLEClientSwitch::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                          esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_REG_EVT:
+      this->publish_state(this->parent_->enabled);
+      break;
+    case ESP_GATTC_OPEN_EVT:
+      this->node_state = espbt::ClientState::Established;
+      break;
+    case ESP_GATTC_DISCONNECT_EVT:
+      this->node_state = espbt::ClientState::Idle;
+      this->publish_state(this->parent_->enabled);
+      break;
+    default:
+      break;
+  }
+}
+
+void BLEClientSwitch::dump_config() { LOG_SWITCH("", "BLE Client Switch", this); }
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_client/switch/ble_switch.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/ble_client/ble_client.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/switch/switch.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace ble_client {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+class BLEClientSwitch : public switch_::Switch, public Component, public BLEClientNode {
+ public:
+  void dump_config() override;
+  void loop() override {}
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace ble_client
+}  // namespace esphome
+#endif

esphome/components/ble_presence/binary_sensor.py

@@ -1,24 +1,54 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import binary_sensor, esp32_ble_tracker
-from esphome.const import CONF_MAC_ADDRESS, CONF_ID
+from esphome.const import CONF_MAC_ADDRESS, CONF_SERVICE_UUID, CONF_ID
 
-DEPENDENCIES = ['esp32_ble_tracker']
+DEPENDENCIES = ["esp32_ble_tracker"]
 
-ble_presence_ns = cg.esphome_ns.namespace('ble_presence')
-BLEPresenceDevice = ble_presence_ns.class_('BLEPresenceDevice', binary_sensor.BinarySensor,
-                                           cg.Component, esp32_ble_tracker.ESPBTDeviceListener)
+ble_presence_ns = cg.esphome_ns.namespace("ble_presence")
+BLEPresenceDevice = ble_presence_ns.class_(
+    "BLEPresenceDevice",
+    binary_sensor.BinarySensor,
+    cg.Component,
+    esp32_ble_tracker.ESPBTDeviceListener,
+)
 
-CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
-    cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
-    cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.All(
+    binary_sensor.BINARY_SENSOR_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
+            cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield esp32_ble_tracker.register_ble_device(var, config)
-    yield binary_sensor.register_binary_sensor(var, config)
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    await binary_sensor.register_binary_sensor(var, config)
 
-    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+    if CONF_MAC_ADDRESS in config:
+        cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+
+    if CONF_SERVICE_UUID in config:
+        if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+            cg.add(
+                var.set_service_uuid16(
+                    esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID])
+                )
+            )
+        elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+            cg.add(
+                var.set_service_uuid32(
+                    esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID])
+                )
+            )
+        elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+            uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_SERVICE_UUID])
+            cg.add(var.set_service_uuid128(uuid128))

esphome/components/ble_presence/ble_presence_device.h

@@ -9,21 +9,46 @@
 namespace esphome {
 namespace ble_presence {
 
-class BLEPresenceDevice : public binary_sensor::BinarySensor,
+class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
                           public esp32_ble_tracker::ESPBTDeviceListener,
                           public Component {
  public:
-  void set_address(uint64_t address) { address_ = address; }
+  void set_address(uint64_t address) {
+    this->by_address_ = true;
+    this->address_ = address;
+  }
+  void set_service_uuid16(uint16_t uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_uint16(uuid);
+  }
+  void set_service_uuid32(uint32_t uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_uint32(uuid);
+  }
+  void set_service_uuid128(uint8_t *uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_raw(uuid);
+  }
   void on_scan_end() override {
     if (!this->found_)
       this->publish_state(false);
     this->found_ = false;
   }
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
-    if (device.address_uint64() == this->address_) {
-      this->publish_state(true);
-      this->found_ = true;
-      return true;
+    if (this->by_address_) {
+      if (device.address_uint64() == this->address_) {
+        this->publish_state(true);
+        this->found_ = true;
+        return true;
+      }
+    } else {
+      for (auto uuid : device.get_service_uuids()) {
+        if (this->uuid_ == uuid) {
+          this->publish_state(device.get_rssi());
+          this->found_ = true;
+          return true;
+        }
+      }
     }
     return false;
   }
@@ -32,7 +57,9 @@ class BLEPresenceDevice : public binary_sensor::BinarySensor,
 
  protected:
   bool found_{false};
+  bool by_address_{false};
   uint64_t address_;
+  esp32_ble_tracker::ESPBTUUID uuid_;
 };
 
 }  // namespace ble_presence

esphome/components/ble_rssi/ble_rssi_sensor.h

@@ -11,17 +11,42 @@ namespace ble_rssi {
 
 class BLERSSISensor : public sensor::Sensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component {
  public:
-  void set_address(uint64_t address) { address_ = address; }
+  void set_address(uint64_t address) {
+    this->by_address_ = true;
+    this->address_ = address;
+  }
+  void set_service_uuid16(uint16_t uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_uint16(uuid);
+  }
+  void set_service_uuid32(uint32_t uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_uint32(uuid);
+  }
+  void set_service_uuid128(uint8_t *uuid) {
+    this->by_address_ = false;
+    this->uuid_ = esp32_ble_tracker::ESPBTUUID::from_raw(uuid);
+  }
   void on_scan_end() override {
     if (!this->found_)
       this->publish_state(NAN);
     this->found_ = false;
   }
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
-    if (device.address_uint64() == this->address_) {
-      this->publish_state(device.get_rssi());
-      this->found_ = true;
-      return true;
+    if (this->by_address_) {
+      if (device.address_uint64() == this->address_) {
+        this->publish_state(device.get_rssi());
+        this->found_ = true;
+        return true;
+      }
+    } else {
+      for (auto uuid : device.get_service_uuids()) {
+        if (this->uuid_ == uuid) {
+          this->publish_state(device.get_rssi());
+          this->found_ = true;
+          return true;
+        }
+      }
     }
     return false;
   }
@@ -30,7 +55,9 @@ class BLERSSISensor : public sensor::Sensor, public esp32_ble_tracker::ESPBTDevi
 
  protected:
   bool found_{false};
+  bool by_address_{false};
   uint64_t address_;
+  esp32_ble_tracker::ESPBTUUID uuid_;
 };
 
 }  // namespace ble_rssi

esphome/components/ble_rssi/sensor.py

@@ -1,24 +1,66 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import sensor, esp32_ble_tracker
-from esphome.const import CONF_MAC_ADDRESS, CONF_ID, UNIT_DECIBEL, ICON_SIGNAL
+from esphome.const import (
+    CONF_SERVICE_UUID,
+    CONF_MAC_ADDRESS,
+    CONF_ID,
+    DEVICE_CLASS_SIGNAL_STRENGTH,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_DECIBEL,
+    ICON_EMPTY,
+)
 
-DEPENDENCIES = ['esp32_ble_tracker']
+DEPENDENCIES = ["esp32_ble_tracker"]
 
-ble_rssi_ns = cg.esphome_ns.namespace('ble_rssi')
-BLERSSISensor = ble_rssi_ns.class_('BLERSSISensor', sensor.Sensor, cg.Component,
-                                   esp32_ble_tracker.ESPBTDeviceListener)
+ble_rssi_ns = cg.esphome_ns.namespace("ble_rssi")
+BLERSSISensor = ble_rssi_ns.class_(
+    "BLERSSISensor", sensor.Sensor, cg.Component, esp32_ble_tracker.ESPBTDeviceListener
+)
 
-CONFIG_SCHEMA = sensor.sensor_schema(UNIT_DECIBEL, ICON_SIGNAL, 0).extend({
-    cv.GenerateID(): cv.declare_id(BLERSSISensor),
-    cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = cv.All(
+    sensor.sensor_schema(
+        UNIT_DECIBEL,
+        ICON_EMPTY,
+        0,
+        DEVICE_CLASS_SIGNAL_STRENGTH,
+        STATE_CLASS_MEASUREMENT,
+    )
+    .extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLERSSISensor),
+            cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
+)
 
 
-def to_code(config):
+async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
-    yield cg.register_component(var, config)
-    yield esp32_ble_tracker.register_ble_device(var, config)
-    yield sensor.register_sensor(var, config)
+    await cg.register_component(var, config)
+    await esp32_ble_tracker.register_ble_device(var, config)
+    await sensor.register_sensor(var, config)
 
-    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+    if CONF_MAC_ADDRESS in config:
+        cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
+
+    if CONF_SERVICE_UUID in config:
+        if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+            cg.add(
+                var.set_service_uuid16(
+                    esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID])
+                )
+            )
+        elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+            cg.add(
+                var.set_service_uuid32(
+                    esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID])
+                )
+            )
+        elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+            uuid128 = esp32_ble_tracker.as_hex_array(config[CONF_SERVICE_UUID])
+            cg.add(var.set_service_uuid128(uuid128))

esphome/components/ble_scanner/ble_scanner.cpp

@@ -0,0 +1,16 @@
+#include "ble_scanner.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_scanner {
+
+static const char *TAG = "ble_scanner";
+
+void BLEScanner::dump_config() { LOG_TEXT_SENSOR("", "BLE Scanner", this); }
+
+}  // namespace ble_scanner
+}  // namespace esphome
+
+#endif

esphome/components/ble_scanner/ble_scanner.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <ctime>
+#include <string>
+
+#include "esphome/core/component.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace ble_scanner {
+
+class BLEScanner : public text_sensor::TextSensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component {
+ public:
+  bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
+    this->publish_state("{\"timestamp\":" + to_string(::time(NULL)) +
+                        ","
+                        "\"address\":\"" +
+                        device.address_str() +
+                        "\","
+                        "\"rssi\":" +
+                        to_string(device.get_rssi()) +
+                        ","
+                        "\"name\":\"" +
+                        device.get_name() + "\"}");
+
+    return true;
+  }
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+};
+
+}  // namespace ble_scanner
+}  // namespace esphome
+
+#endif

esphome/components/ble_scanner/text_sensor.py

@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import text_sensor, esp32_ble_tracker
+from esphome.const import CONF_ID
+
+DEPENDENCIES = ["esp32_ble_tracker"]
+
+ble_scanner_ns = cg.esphome_ns.namespace("ble_scanner")
+BLEScanner = ble_scanner_ns.class_(
+    "BLEScanner",
+    text_sensor.TextSensor,
+    cg.Component,
+    esp32_ble_tracker.ESPBTDeviceListener,
+)
+
+CONFIG_SCHEMA = cv.All(
+    text_sensor.TEXT_SENSOR_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(BLEScanner),
+        }
+    )
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA)
+)
+
+
+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)
+    await text_sensor.register_text_sensor(var, config)

esphome/components/bme280/bme280.cpp

@@ -146,7 +146,7 @@ void BME280Component::dump_config() {
       ESP_LOGE(TAG, "Communication with BME280 failed!");
       break;
     case WRONG_CHIP_ID:
-      ESP_LOGE(TAG, "BMP280 has wrong chip ID! Is it a BMP280?");
+      ESP_LOGE(TAG, "BME280 has wrong chip ID! Is it a BME280?");
       break;
     case NONE:
     default:
@@ -172,13 +172,13 @@ void BME280Component::update() {
   uint8_t meas_register = 0;
   meas_register |= (this->temperature_oversampling_ & 0b111) << 5;
   meas_register |= (this->pressure_oversampling_ & 0b111) << 2;
-  meas_register |= 0b01;  // Forced mode
+  meas_register |= BME280_MODE_FORCED;
   if (!this->write_byte(BME280_REGISTER_CONTROL, meas_register)) {
     this->status_set_warning();
     return;
   }
 
-  float meas_time = 1;
+  float meas_time = 1.5;
   meas_time += 2.3f * oversampling_to_time(this->temperature_oversampling_);
   meas_time += 2.3f * oversampling_to_time(this->pressure_oversampling_) + 0.575f;
   meas_time += 2.3f * oversampling_to_time(this->humidity_oversampling_) + 0.575f;

esphome/components/bme280/sensor.py

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

esphome/components/bme680/sensor.py

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

esphome/components/bme680_bsec/__init__.py

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

esphome/components/bme680_bsec/bme680_bsec.cpp

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

esphome/components/bme680_bsec/bme680_bsec.h

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

esphome/components/bme680_bsec/sensor.py

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

esphome/components/bme680_bsec/text_sensor.py

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

esphome/components/bmp085/sensor.py

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

esphome/components/bmp280/sensor.py

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

esphome/components/canbus/__init__.py

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

esphome/components/canbus/canbus.cpp

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

esphome/components/canbus/canbus.h

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

esphome/components/captive_portal/__init__.py

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

esphome/components/captive_portal/captive_portal.cpp

@@ -0,0 +1,153 @@
+#include "captive_portal.h"
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "esphome/components/wifi/wifi_component.h"
+
+namespace esphome {
+namespace captive_portal {
+
+static const char *TAG = "captive_portal";
+
+void CaptivePortal::handle_index(AsyncWebServerRequest *request) {
+  AsyncResponseStream *stream = request->beginResponseStream("text/html");
+  stream->print(F("<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"UTF-8\"><meta name=\"viewport\" "
+                  "content=\"width=device-width,initial-scale=1,user-scalable=no\"/><title>"));
+  stream->print(App.get_name().c_str());
+  stream->print(F("</title><link rel=\"stylesheet\" href=\"/stylesheet.css\">"));
+  stream->print(F("<script>function c(l){document.getElementById('ssid').value=l.innerText||l.textContent; "
+                  "document.getElementById('psk').focus();}</script>"));
+  stream->print(F("</head>"));
+  stream->print(F("<body><div class=\"main\"><h1>WiFi Networks</h1>"));
+
+  if (request->hasArg("save")) {
+    stream->print(F("<div class=\"info\">The ESP will now try to connect to the network...<br/>Please give it some "
+                    "time to connect.<br/>Note: Copy the changed network to your YAML file - the next OTA update will "
+                    "overwrite these settings.</div>"));
+  }
+
+  for (auto &scan : wifi::global_wifi_component->get_scan_result()) {
+    if (scan.get_is_hidden())
+      continue;
+
+    stream->print(F("<div class=\"network\" onclick=\"c(this)\"><a href=\"#\" class=\"network-left\">"));
+
+    if (scan.get_rssi() >= -50) {
+      stream->print(F("<img src=\"/wifi-strength-4.svg\">"));
+    } else if (scan.get_rssi() >= -65) {
+      stream->print(F("<img src=\"/wifi-strength-3.svg\">"));
+    } else if (scan.get_rssi() >= -85) {
+      stream->print(F("<img src=\"/wifi-strength-2.svg\">"));
+    } else {
+      stream->print(F("<img src=\"/wifi-strength-1.svg\">"));
+    }
+
+    stream->print(F("<span class=\"network-ssid\">"));
+    stream->print(scan.get_ssid().c_str());
+    stream->print(F("</span></a>"));
+    if (scan.get_with_auth()) {
+      stream->print(F("<img src=\"/lock.svg\">"));
+    }
+    stream->print(F("</div>"));
+  }
+
+  stream->print(F("<h3>WiFi Settings</h3><form method=\"GET\" action=\"/wifisave\"><input id=\"ssid\" name=\"ssid\" "
+                  "length=32 placeholder=\"SSID\"><br/><input id=\"psk\" name=\"psk\" length=64 type=\"password\" "
+                  "placeholder=\"Password\"><br/><br/><button type=\"submit\">Save</button></form><br><hr><br>"));
+  stream->print(F("<h1>OTA Update</h1><form method=\"POST\" action=\"/update\" enctype=\"multipart/form-data\"><input "
+                  "type=\"file\" name=\"update\"><button type=\"submit\">Update</button></form>"));
+  stream->print(F("</div></body></html>"));
+  request->send(stream);
+}
+void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
+  std::string ssid = request->arg("ssid").c_str();
+  std::string psk = request->arg("psk").c_str();
+  ESP_LOGI(TAG, "Captive Portal Requested WiFi Settings Change:");
+  ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
+  ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
+  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
+  request->redirect("/?save=true");
+}
+
+void CaptivePortal::setup() {}
+void CaptivePortal::start() {
+  this->base_->init();
+  if (!this->initialized_) {
+    this->base_->add_handler(this);
+    this->base_->add_ota_handler();
+  }
+
+  this->dns_server_ = new DNSServer();
+  this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
+  IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
+  this->dns_server_->start(53, "*", ip);
+
+  this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {
+    bool not_found = false;
+    if (!this->active_) {
+      not_found = true;
+    } else if (req->host() == wifi::global_wifi_component->wifi_soft_ap_ip().toString()) {
+      not_found = true;
+    }
+
+    if (not_found) {
+      req->send(404, "text/html", "File not found");
+      return;
+    }
+
+    auto url = "http://" + wifi::global_wifi_component->wifi_soft_ap_ip().toString();
+    req->redirect(url);
+  });
+
+  this->initialized_ = true;
+  this->active_ = true;
+}
+
+const char STYLESHEET_CSS[] PROGMEM =
+    R"(*{box-sizing:inherit}div,input{padding:5px;font-size:1em}input{width:95%}body{text-align:center;font-family:sans-serif}button{border:0;border-radius:.3rem;background-color:#1fa3ec;color:#fff;line-height:2.4rem;font-size:1.2rem;width:100%;padding:0}.main{text-align:left;display:inline-block;min-width:260px}.network{display:flex;justify-content:space-between;align-items:center}.network-left{display:flex;align-items:center}.network-ssid{margin-bottom:-7px;margin-left:10px}.info{border:1px solid;margin:10px 0;padding:15px 10px;color:#4f8a10;background-color:#dff2bf})";
+const char LOCK_SVG[] PROGMEM =
+    R"(<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24"><path d="M12 17a2 2 0 0 0 2-2 2 2 0 0 0-2-2 2 2 0 0 0-2 2 2 2 0 0 0 2 2m6-9a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V10a2 2 0 0 1 2-2h1V6a5 5 0 0 1 5-5 5 5 0 0 1 5 5v2h1m-6-5a3 3 0 0 0-3 3v2h6V6a3 3 0 0 0-3-3z"/></svg>)";
+
+void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
+  if (req->url() == "/") {
+    this->handle_index(req);
+    return;
+  } else if (req->url() == "/wifisave") {
+    this->handle_wifisave(req);
+    return;
+  } else if (req->url() == "/stylesheet.css") {
+    req->send_P(200, "text/css", STYLESHEET_CSS);
+    return;
+  } else if (req->url() == "/lock.svg") {
+    req->send_P(200, "image/svg+xml", LOCK_SVG);
+    return;
+  }
+
+  AsyncResponseStream *stream = req->beginResponseStream("image/svg+xml");
+  stream->print(F("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"><path d=\"M12 3A18.9 18.9 0 0 "
+                  "0 .38 7C4.41 12.06 7.89 16.37 12 21.5L23.65 7C20.32 4.41 16.22 3 12 "));
+  if (req->url() == "/wifi-strength-4.svg") {
+    stream->print(F("3z"));
+  } else {
+    if (req->url() == "/wifi-strength-1.svg") {
+      stream->print(F("3m0 2c3.07 0 6.09.86 8.71 2.45l-5.1 6.36a8.43 8.43 0 0 0-7.22-.01L3.27 7.4"));
+    } else if (req->url() == "/wifi-strength-2.svg") {
+      stream->print(F("3m0 2c3.07 0 6.09.86 8.71 2.45l-3.21 3.98a11.32 11.32 0 0 0-11 0L3.27 7.4"));
+    } else if (req->url() == "/wifi-strength-3.svg") {
+      stream->print(F("3m0 2c3.07 0 6.09.86 8.71 2.45l-1.94 2.43A13.6 13.6 0 0 0 12 8C9 8 6.68 9 5.21 9.84l-1.94-2."));
+    }
+    stream->print(F("4A16.94 16.94 0 0 1 12 5z"));
+  }
+  stream->print(F("\"/></svg>"));
+  req->send(stream);
+}
+CaptivePortal::CaptivePortal(web_server_base::WebServerBase *base) : base_(base) { global_captive_portal = this; }
+float CaptivePortal::get_setup_priority() const {
+  // Before WiFi
+  return setup_priority::WIFI + 1.0f;
+}
+void CaptivePortal::dump_config() { ESP_LOGCONFIG(TAG, "Captive Portal:"); }
+
+CaptivePortal *global_captive_portal = nullptr;
+
+}  // namespace captive_portal
+}  // namespace esphome

esphome/components/captive_portal/captive_portal.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <DNSServer.h>
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/preferences.h"
+#include "esphome/components/web_server_base/web_server_base.h"
+
+namespace esphome {
+
+namespace captive_portal {
+
+class CaptivePortal : public AsyncWebHandler, public Component {
+ public:
+  CaptivePortal(web_server_base::WebServerBase *base);
+  void setup() override;
+  void dump_config() override;
+  void loop() override {
+    if (this->dns_server_ != nullptr)
+      this->dns_server_->processNextRequest();
+  }
+  float get_setup_priority() const override;
+  void start();
+  bool is_active() const { return this->active_; }
+  void end() {
+    this->active_ = false;
+    this->base_->deinit();
+    this->dns_server_->stop();
+    delete this->dns_server_;
+  }
+
+  bool canHandle(AsyncWebServerRequest *request) override {
+    if (!this->active_)
+      return false;
+
+    if (request->method() == HTTP_GET) {
+      if (request->url() == "/")
+        return true;
+      if (request->url() == "/stylesheet.css")
+        return true;
+      if (request->url() == "/wifi-strength-1.svg")
+        return true;
+      if (request->url() == "/wifi-strength-2.svg")
+        return true;
+      if (request->url() == "/wifi-strength-3.svg")
+        return true;
+      if (request->url() == "/wifi-strength-4.svg")
+        return true;
+      if (request->url() == "/lock.svg")
+        return true;
+      if (request->url() == "/wifisave")
+        return true;
+    }
+
+    return false;
+  }
+
+  void handle_index(AsyncWebServerRequest *request);
+
+  void handle_wifisave(AsyncWebServerRequest *request);
+
+  void handleRequest(AsyncWebServerRequest *req) override;
+
+ protected:
+  web_server_base::WebServerBase *base_;
+  bool initialized_{false};
+  bool active_{false};
+  DNSServer *dns_server_{nullptr};
+};
+
+extern CaptivePortal *global_captive_portal;
+
+}  // namespace captive_portal
+}  // namespace esphome

esphome/components/captive_portal/index.html

@@ -0,0 +1,55 @@
+<!-- HTTP_HEAD -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no"/>
+    <title>{{ App.get_name() }}</title>
+    <link rel="stylesheet" href="./stylesheet.css">
+    <script>
+        function c(l) {
+            document.getElementById('ssid').value = l.innerText || l.textContent;
+            document.getElementById('psk').focus();
+        }
+    </script>
+</head>
+<body>
+<div class="main">
+    <h1>WiFi Networks</h1>
+    <div class="info">
+        The ESP will now try to connect to the network...<br/>
+        Please give it some time to connect.<br/>
+        Note: Copy the changed network to your YAML file - the next OTA update will overwrite these settings.
+    </div>
+    <div class="network" onclick="c(this)">
+        <a href="#" class="network-left">
+            <img src="./wifi-strength-4.svg">
+            <span class="network-ssid">AP1</span>
+        </a>
+        <img src="./lock.svg">
+    </div>
+    <div class="network" onclick="c(this)">
+        <a href="#" class="network-left">
+            <img src="./wifi-strength-2.svg">
+            <span class="network-ssid">AP2</span>
+        </a>
+    </div>
+
+    <h3>WiFi Settings</h3>
+    <form method="GET" action="/wifisave">
+        <input id="ssid" name="ssid" length=32 placeholder="SSID"><br/>
+        <input id="psk" name="psk" length=64 type="password" placeholder="Password"><br/>
+        <br/>
+        <button type="submit">Save</button>
+    </form>
+    <br><hr>
+    <br>
+
+    <h1>OTA Update</h1>
+    <form method="POST" action="/update" enctype="multipart/form-data">
+        <input type="file" name="update">
+        <button type="submit">Update</button>
+    </form>
+</div>
+</body>
+</html>

esphome/components/captive_portal/lock.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24"><path d="M12 17a2 2 0 0 0 2-2 2 2 0 0 0-2-2 2 2 0 0 0-2 2 2 2 0 0 0 2 2m6-9a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V10a2 2 0 0 1 2-2h1V6a5 5 0 0 1 5-5 5 5 0 0 1 5 5v2h1m-6-5a3 3 0 0 0-3 3v2h6V6a3 3 0 0 0-3-3z"/></svg>

esphome/components/captive_portal/stylesheet.css

@@ -0,0 +1,58 @@
+* {
+    box-sizing: inherit;
+}
+
+div, input {
+    padding: 5px;
+    font-size: 1em;
+}
+
+input {
+    width: 95%;
+}
+
+body {
+    text-align: center;
+    font-family: sans-serif;
+}
+
+button {
+    border: 0;
+    border-radius: 0.3rem;
+    background-color: #1fa3ec;
+    color: #fff;
+    line-height: 2.4rem;
+    font-size: 1.2rem;
+    width: 100%;
+    padding: 0;
+}
+
+.main {
+    text-align: left;
+    display: inline-block;
+    min-width: 260px;
+}
+
+.network {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.network-left {
+    display: flex;
+    align-items: center;
+}
+
+.network-ssid {
+    margin-bottom: -7px;
+    margin-left: 10px;
+}
+
+.info {
+    border: 1px solid;
+    margin: 10px 0px;
+    padding: 15px 10px;
+    color: #4f8a10;
+    background-color: #dff2bf;
+}

esphome/components/captive_portal/wifi-strength-1.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M12 3A18.9 18.9 0 0 0 .38 7C4.41 12.06 7.89 16.37 12 21.5L23.65 7C20.32 4.41 16.22 3 12 3m0 2c3.07 0 6.09.86 8.71 2.45l-5.1 6.36a8.43 8.43 0 0 0-7.22-.01L3.27 7.44A16.94 16.94 0 0 1 12 5z"/></svg>

esphome/components/captive_portal/wifi-strength-2.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M12 3A18.9 18.9 0 0 0 .38 7C4.41 12.06 7.89 16.37 12 21.5L23.65 7C20.32 4.41 16.22 3 12 3m0 2c3.07 0 6.09.86 8.71 2.45l-3.21 3.98a11.32 11.32 0 0 0-11 0L3.27 7.44A16.94 16.94 0 0 1 12 5z"/></svg>

esphome/components/captive_portal/wifi-strength-3.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M12 3A18.9 18.9 0 0 0 .38 7C4.41 12.06 7.89 16.37 12 21.5L23.65 7C20.32 4.41 16.22 3 12 3m0 2c3.07 0 6.09.86 8.71 2.45l-1.94 2.43A13.6 13.6 0 0 0 12 8C9 8 6.68 9 5.21 9.84l-1.94-2.4A16.94 16.94 0 0 1 12 5z"/></svg>

esphome/components/captive_portal/wifi-strength-4.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path d="M12 3A18.9 18.9 0 0 0 .38 7C4.41 12.06 7.89 16.37 12 21.5L23.65 7C20.32 4.41 16.22 3 12 3z"/></svg>

esphome/components/ccs811/ccs811.cpp

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