Merge pull request #2091 from esphome/bump-1.20.2

1.20.2

.clang-format

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

.clang-tidy

@@ -5,30 +5,19 @@ Checks: >-
   -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-optin.cplusplus.UninitializedObject,
   -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,
@@ -45,17 +34,17 @@ Checks: >-
   -cppcoreguidelines-pro-type-union-access,
   -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-special-member-functions,
-  -fuchsia-*,
   -fuchsia-default-arguments,
   -fuchsia-multiple-inheritance,
   -fuchsia-overloaded-operator,
   -fuchsia-statically-constructed-objects,
+  -fuchsia-default-arguments-declarations,
+  -fuchsia-default-arguments-calls,
   -google-build-using-namespace,
   -google-explicit-constructor,
   -google-readability-braces-around-statements,
   -google-readability-casting,
   -google-readability-todo,
-  -google-runtime-int,
   -google-runtime-references,
   -hicpp-*,
   -llvm-else-after-return,
@@ -65,12 +54,8 @@ Checks: >-
   -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,
   -modernize-return-braced-init-list,
   -modernize-use-auto,
   -modernize-use-default-member-init,
@@ -78,7 +63,6 @@ Checks: >-
   -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,
@@ -94,8 +78,7 @@ Checks: >-
   -readability-redundant-string-init,
   -readability-uppercase-literal-suffix,
   -readability-use-anyofallof,
-  -warnings-as-errors,
-  -zircon-*
+  -warnings-as-errors
 WarningsAsErrors: '*'
 HeaderFilterRegex: '^.*/src/esphome/.*'
 AnalyzeTemporaryDtors: false

.devcontainer/devcontainer.json

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

.dockerignore

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

.editorconfig

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

.github/workflows/ci-docker.yml

@@ -3,7 +3,7 @@ name: CI for docker images
 # Only run when docker paths change
 on:
   push:
-    branches: [dev, beta, master]
+    branches: [dev, beta, release]
     paths:
       - 'docker/**'
       - '.github/workflows/**'
@@ -18,38 +18,23 @@ jobs:
     name: Build docker containers
     runs-on: ubuntu-latest
     strategy:
-      fail-fast: false
       matrix:
         arch: [amd64, armv7, aarch64]
-        build_type: ["hassio", "docker"]
+        build_type: ["ha-addon", "docker", "lint"]
     steps:
-      - uses: actions/checkout@v2
-      - name: Set up env variables
-        run: |
-          base_version="3.4.0"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=check" >> $GITHUB_ENV
 
-          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
-            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile.hassio"
-          else
-            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile"
-          fi
-
-          echo "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}" \
-            .
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build

.github/workflows/ci.yml

@@ -4,40 +4,36 @@ name: CI
 
 on:
   push:
-    # On dev branch release-dev already performs CI checks
-    # On other branches the `pull_request` trigger will be used
-    branches: [beta, master]
+    branches: [dev, beta, release]
 
   pull_request:
 
 jobs:
-  lint-clang-format:
+  ci-with-container:
+    name: ${{ matrix.name }}
     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]
+        include:
+          - id: clang-format
+            name: Run script/clang-format
+          - id: clang-tidy
+            name: Run script/clang-tidy 1/4
+            split: 1
+          - id: clang-tidy
+            name: Run script/clang-tidy 2/4
+            split: 2
+          - id: clang-tidy
+            name: Run script/clang-tidy 3/4
+            split: 3
+          - id: clang-tidy
+            name: Run script/clang-tidy 4/4
+            split: 4
+
+    # cpp lint job runs with esphome-lint docker image so that clang-format-*
+    # doesn't have to be installed
+    container: ghcr.io/esphome/esphome-lint:1.1
     steps:
       - uses: actions/checkout@v2
       # Set up the pio project so that the cpp checks know how files are compiled
@@ -45,26 +41,57 @@ jobs:
       - 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-format
+        run: script/clang-format -i
+        if: ${{ matrix.id == 'clang-format' }}
+
       - name: Run clang-tidy
         run: script/clang-tidy --all-headers --fix --split-num 4 --split-at ${{ matrix.split }}
+        if: ${{ matrix.id == 'clang-tidy' }}
+
       - name: Suggest changes
         run: script/ci-suggest-changes
 
-  lint-python:
+  ci:
     # Don't use the esphome-lint docker image because it may contain outdated requirements.
     # This way, all dependencies are cached via the cache action.
+    name: ${{ matrix.name }}
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - id: ci-custom
+            name: Run script/ci-custom
+          - id: lint-python
+            name: Run script/lint-python
+          - id: test
+            file: tests/test1.yaml
+            name: Test tests/test1.yaml
+          - id: test
+            file: tests/test2.yaml
+            name: Test tests/test2.yaml
+          - id: test
+            file: tests/test3.yaml
+            name: Test tests/test3.yaml
+          - id: test
+            file: tests/test4.yaml
+            name: Test tests/test4.yaml
+          - id: pytest
+            name: Run pytest
+
     steps:
       - uses: actions/checkout@v2
       - name: Set up Python
         uses: actions/setup-python@v2
         with:
           python-version: '3.7'
+
       - name: Cache pip modules
         uses: actions/cache@v1
         with:
@@ -72,6 +99,17 @@ jobs:
           key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
           restore-keys: |
             esphome-pip-3.7-
+
+      # Use per test platformio cache because tests have different platform versions
+      - name: Cache ~/.platformio
+        uses: actions/cache@v1
+        with:
+          path: ~/.platformio
+          key: test-home-platformio-${{ matrix.file }}-${{ hashFiles('esphome/core/config.py') }}
+          restore-keys: |
+            test-home-platformio-${{ matrix.file }}-
+        if: ${{ matrix.id == 'test' }}
+
       - name: Set up python environment
         run: script/setup
 
@@ -80,82 +118,22 @@ jobs:
           echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
           echo "::add-matcher::.github/workflows/matchers/lint-python.json"
           echo "::add-matcher::.github/workflows/matchers/python.json"
+          echo "::add-matcher::.github/workflows/matchers/pytest.json"
+          echo "::add-matcher::.github/workflows/matchers/gcc.json"
+
       - name: Lint Custom
-        run: script/ci-custom.py
+        run: |
+          script/ci-custom.py
+          script/build_codeowners.py --check
+        if: ${{ matrix.id == 'ci-custom' }}
       - name: Lint Python
         run: script/lint-python
-      - name: Lint CODEOWNERS
-        run: script/build_codeowners.py --check
+        if: ${{ matrix.id == 'lint-python' }}
 
-  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
+      - run: esphome compile ${{ matrix.file }}
+        if: ${{ matrix.id == 'test' }}
 
-
-      - 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
+          pytest -vv --tb=native tests
+        if: ${{ matrix.id == 'pytest' }}

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

@@ -13,30 +13,88 @@ on:
       - '.github/workflows/docker-lint-build.yml'
 
 jobs:
-  publish-docker-lint-iage:
-    name: Build docker containers
+  deploy-docker:
+    name: Build and publish docker containers
+    if: github.repository == 'esphome/esphome'
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        arch: [amd64, armv7, aarch64]
+        build_type: ["lint"]
     steps:
-      - uses: actions/checkout@v2
-      - name: Set 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"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=1.1" >> $GITHUB_ENV
+
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build
+
+    - name: Log in to docker hub
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Run push
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          push
+
+  deploy-docker-manifest:
+    if: github.repository == 'esphome/esphome'
+    runs-on: ubuntu-latest
+    needs: [deploy-docker]
+    strategy:
+      matrix:
+        build_type: ["lint"]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+    - name: Set TAG
+      run: |
+        echo "TAG=1.1" >> $GITHUB_ENV
+    - name: Enable experimental manifest support
+      run: |
+        mkdir -p ~/.docker
+        echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
+
+    - name: Log in to docker hub
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Run manifest
+      run: |
+        docker/build.py \
+          --tag "${TAG}" \
+          --build-type "${{ matrix.build_type }}" \
+          manifest

.github/workflows/matchers/pytest.json

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

.github/workflows/release-dev.yml

@@ -1,247 +0,0 @@
-name: Publish dev releases to docker hub
-
-on:
-  push:
-    branches:
-    - dev
-
-jobs:
-  # THE LINT/TEST JOBS ARE COPIED FROM ci.yaml
-
-  lint-clang-format:
-    runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint: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

@@ -1,164 +1,35 @@
 name: Publish Release
 
 on:
+  workflow_dispatch:
   release:
     types: [published]
+  schedule:
+    - cron: "0 2 * * *"
 
 jobs:
-  # THE LINT/TEST JOBS ARE COPIED FROM ci.yaml
-
-  lint-clang-format:
+  init:
+    name: Initialize build
     runs-on: ubuntu-latest
-    # cpp lint job runs with esphome-lint docker image so that clang-format-*
-    # doesn't have to be installed
-    container: esphome/esphome-lint:1.1
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
     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
+      - name: Get tag
+        id: tag
         run: |
-          echo "::add-matcher::.github/workflows/matchers/clang-tidy.json"
-          echo "::add-matcher::.github/workflows/matchers/gcc.json"
-      - name: Run clang-tidy
-        run: script/clang-tidy --all-headers --fix --split-num 4 --split-at ${{ matrix.split }}
-      - name: Suggest changes
-        run: script/ci-suggest-changes
-
-  lint-python:
-    # Don't use the esphome-lint docker image because it may contain outdated requirements.
-    # This way, all dependencies are cached via the cache action.
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.7'
-      - name: Cache pip modules
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/pip
-          key: esphome-pip-3.7-${{ hashFiles('setup.py') }}
-          restore-keys: |
-            esphome-pip-3.7-
-      - name: Set up python environment
-        run: script/setup
-
-      - name: Register problem matchers
-        run: |
-          echo "::add-matcher::.github/workflows/matchers/ci-custom.json"
-          echo "::add-matcher::.github/workflows/matchers/lint-python.json"
-          echo "::add-matcher::.github/workflows/matchers/python.json"
-      - name: Lint Custom
-        run: script/ci-custom.py
-      - name: Lint Python
-        run: script/lint-python
-      - name: Lint CODEOWNERS
-        run: script/build_codeowners.py --check
-
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      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
+          if [[ "$GITHUB_EVENT_NAME" = "release" ]]; then
+            TAG="${GITHUB_REF#refs/tags/v}"
+          else
+            TAG=$(cat esphome/const.py | sed -n -E "s/^__version__\s+=\s+\"(.+)\"$/\1/p")
+            today="$(date --utc '+%Y%m%d')"
+            TAG="${TAG}${today}"
+          fi
+          echo "::set-output name=tag::${TAG}"
 
   deploy-pypi:
     name: Build and publish to PyPi
-    if: github.repository == 'esphome/esphome'
-    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
+    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -182,119 +53,85 @@ jobs:
     name: Build and publish docker containers
     if: github.repository == 'esphome/esphome'
     runs-on: ubuntu-latest
-    needs: [lint-clang-format, lint-clang-tidy, lint-python, test, pytest]
+    needs: [init]
     strategy:
       matrix:
         arch: [amd64, armv7, aarch64]
-        build_type: ["hassio", "docker"]
+        build_type: ["ha-addon", "docker"]
     steps:
-      - uses: actions/checkout@v2
-      - name: Set TAG
-        run: |
-          TAG="${GITHUB_REF#refs/tags/v}"
-          echo "TAG=${TAG}" >> $GITHUB_ENV
-      - name: Set up env variables
-        run: |
-          base_version="3.4.0"
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
 
-          if [[ "${{ matrix.build_type }}" == "hassio" ]]; then
-            build_from="esphome/esphome-hassio-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-hassio-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile.hassio"
-          else
-            build_from="esphome/esphome-base-${{ matrix.arch }}:${base_version}"
-            build_to="esphome/esphome-${{ matrix.arch }}"
-            dockerfile="docker/Dockerfile"
-          fi
+    - name: Run build
+      run: |
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          build
 
-          if [[ "${{ github.event.release.prerelease }}" == "true" ]]; then
-            cache_tag="beta"
-          else
-            cache_tag="latest"
-          fi
+    - name: Log in to docker hub
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-          # Set env variables so these values don't need to be calculated again
-          echo "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"
+    - name: Run push
+      run: |
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --arch "${{ matrix.arch }}" \
+          --build-type "${{ matrix.build_type }}" \
+          push
 
   deploy-docker-manifest:
     if: github.repository == 'esphome/esphome'
     runs-on: ubuntu-latest
-    needs: [deploy-docker]
+    needs: [init, deploy-docker]
+    strategy:
+      matrix:
+        build_type: ["ha-addon", "docker"]
     steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
     - name: Enable experimental manifest support
       run: |
         mkdir -p ~/.docker
         echo "{\"experimental\": \"enabled\"}" > ~/.docker/config.json
-    - name: Set TAG
-      run: |
-        TAG="${GITHUB_REF#refs/tags/v}"
-        echo "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}
+      uses: docker/login-action@v1
+      with:
+        username: ${{ secrets.DOCKER_USER }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+    - name: Log in to the GitHub container registry
+      uses: docker/login-action@v1
+      with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-    - name: Publish docker beta tag
+    - name: Run manifest
       run: |
-        docker manifest create esphome/esphome:beta \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:beta
-
-    - name: Publish docker latest tag
-      if: ${{ !github.event.release.prerelease }}
-      run: |
-        docker manifest create esphome/esphome:latest \
-          esphome/esphome-aarch64:${TAG} \
-          esphome/esphome-amd64:${TAG} \
-          esphome/esphome-armv7:${TAG}
-        docker manifest push esphome/esphome:latest
+        docker/build.py \
+          --tag "${{ needs.init.outputs.tag }}" \
+          --build-type "${{ matrix.build_type }}" \
+          manifest
 
   deploy-hassio-repo:
-    if: github.repository == 'esphome/esphome'
+    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
     needs: [deploy-docker]
     steps:
@@ -307,4 +144,4 @@ jobs:
             -X POST \
             -H "Accept: application/vnd.github.v3+json" \
             https://api.github.com/repos/esphome/hassio/actions/workflows/bump-version.yml/dispatches \
-            -d "{\"ref\":\"master\",\"inputs\":{\"version\":\"$TAG\"}}"
+            -d "{\"ref\":\"main\",\"inputs\":{\"version\":\"$TAG\"}}"

.gitignore

@@ -13,6 +13,9 @@ __pycache__/
 # Intellij Idea
 .idea
 
+# Vim
+*.swp
+
 # Hide some OS X stuff
 .DS_Store
 .AppleDouble

.pre-commit-config.yaml

@@ -23,5 +23,5 @@ repos:
       - id: no-commit-to-branch
         args:
           - --branch=dev
-          - --branch=master
+          - --branch=release
           - --branch=beta

.vscode/tasks.json

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

CODEOWNERS

@@ -15,10 +15,12 @@ esphome/components/ac_dimmer/* @glmnet
 esphome/components/adc/* @esphome/core
 esphome/components/addressable_light/* @justfalter
 esphome/components/animation/* @syndlex
+esphome/components/anova/* @buxtronix
 esphome/components/api/* @OttoWinter
 esphome/components/async_tcp/* @OttoWinter
 esphome/components/atc_mithermometer/* @ahpohl
 esphome/components/b_parasite/* @rbaron
+esphome/components/ballu/* @bazuchan
 esphome/components/bang_bang/* @OttoWinter
 esphome/components/binary_sensor/* @esphome/core
 esphome/components/ble_client/* @buxtronix
@@ -45,6 +47,7 @@ esphome/components/fingerprint_grow/* @OnFreund @loongyh
 esphome/components/globals/* @esphome/core
 esphome/components/gpio/* @esphome/core
 esphome/components/gps/* @coogle
+esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/homeassistant/* @OttoWinter
 esphome/components/i2c/* @esphome/core
 esphome/components/improv/* @jesserockz
@@ -70,7 +73,13 @@ esphome/components/midea_ac/* @dudanov
 esphome/components/midea_dongle/* @dudanov
 esphome/components/mitsubishi/* @RubyBailey
 esphome/components/network/* @esphome/core
+esphome/components/nextion/* @senexcrenshaw
+esphome/components/nextion/binary_sensor/* @senexcrenshaw
+esphome/components/nextion/sensor/* @senexcrenshaw
+esphome/components/nextion/switch/* @senexcrenshaw
+esphome/components/nextion/text_sensor/* @senexcrenshaw
 esphome/components/nfc/* @jesserockz
+esphome/components/number/* @esphome/core
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/pid/* @OttoWinter

README.md

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

docker/Dockerfile

@@ -1,4 +1,4 @@
-ARG BUILD_FROM=esphome/esphome-base-amd64:3.4.0
+ARG BUILD_FROM=esphome/esphome-base:latest
 FROM ${BUILD_FROM}
 
 # First install requirements to leverage caching when requirements don't change

docker/Dockerfile.dev

@@ -1,13 +1 @@
-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
+FROM esphome/esphome-lint:1.1

docker/Dockerfile.hassio

@@ -1,4 +1,4 @@
-ARG BUILD_FROM
+ARG BUILD_FROM=esphome/esphome-hassio-base:latest
 FROM ${BUILD_FROM}
 
 # First install requirements to leverage caching when requirements don't change

docker/Dockerfile.lint

@@ -1,4 +1,5 @@
-FROM esphome/esphome-lint-base:3.4.0
+ARG BUILD_FROM=esphome/esphome-lint-base:latest
+FROM ${BUILD_FROM}
 
 COPY requirements.txt requirements_optional.txt requirements_test.txt docker/platformio_install_deps.py  platformio.ini /
 RUN \

docker/build.py

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

esphome/__main__.py

@@ -514,14 +514,26 @@ def parse_args(argv):
 
     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
+    deprecated_argv_suggestion = None
+
+    if ["dashboard", "config"] == argv[1:3] or ["version"] == argv[1:2]:
+        # this is most likely meant in new-style arg format. do not try compat parsing
+        pass
+    else:
+        try:
+            result, unparsed = compat_parser.parse_known_args(argv[1:])
+            last_option = len(argv) - len(unparsed) - 1 - len(result.configuration)
+            unparsed = [
+                "--device" if arg in ("--upload-port", "--serial-port") else arg
+                for arg in unparsed
+            ]
+            argv = (
+                argv[0:last_option] + [result.command] + result.configuration + unparsed
+            )
+            deprecated_argv_suggestion = argv
+        except argparse.ArgumentError:
+            # This is not an old-style command line, so we don't have to do anything.
+            pass
 
     # And continue on with regular parsing
     parser = argparse.ArgumentParser(

esphome/codegen.py

@@ -60,6 +60,7 @@ from esphome.cpp_types import (  # noqa
     uint8,
     uint16,
     uint32,
+    uint64,
     int32,
     const_char_ptr,
     NAN,

esphome/components/a4988/a4988.cpp

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

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -9,15 +9,15 @@
 namespace esphome {
 namespace ac_dimmer {
 
-static const char *TAG = "ac_dimmer";
+static const char *const TAG = "ac_dimmer";
 
 // Global array to store dimmer objects
-static AcDimmerDataStore *all_dimmers[32];
+static AcDimmerDataStore *all_dimmers[32];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 /// Time in microseconds the gate should be held high
 /// 10µs should be long enough for most triacs
 /// For reference: BT136 datasheet says 2µs nominal (page 7)
-static uint32_t GATE_ENABLE_TIME = 10;
+static const uint32_t GATE_ENABLE_TIME = 10;
 
 /// Function called from timer interrupt
 /// Input is current time in microseconds (micros())

esphome/components/adalight/adalight_light_effect.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace adalight {
 
-static const char *TAG = "adalight_light_effect";
+static const char *const TAG = "adalight_light_effect";
 
 static const uint32_t ADALIGHT_ACK_INTERVAL = 1000;
 static const uint32_t ADALIGHT_RECEIVE_TIMEOUT = 1000;

esphome/components/adc/adc_sensor.cpp

@@ -8,10 +8,33 @@ ADC_MODE(ADC_VCC)
 namespace esphome {
 namespace adc {
 
-static const char *TAG = "adc";
+static const char *const TAG = "adc";
 
 #ifdef ARDUINO_ARCH_ESP32
-void ADCSensor::set_attenuation(adc_attenuation_t attenuation) { this->attenuation_ = attenuation; }
+void ADCSensor::set_attenuation(adc_atten_t attenuation) { this->attenuation_ = attenuation; }
+
+inline adc1_channel_t gpio_to_adc1(uint8_t pin) {
+  switch (pin) {
+    case 36:
+      return ADC1_CHANNEL_0;
+    case 37:
+      return ADC1_CHANNEL_1;
+    case 38:
+      return ADC1_CHANNEL_2;
+    case 39:
+      return ADC1_CHANNEL_3;
+    case 32:
+      return ADC1_CHANNEL_4;
+    case 33:
+      return ADC1_CHANNEL_5;
+    case 34:
+      return ADC1_CHANNEL_6;
+    case 35:
+      return ADC1_CHANNEL_7;
+    default:
+      return ADC1_CHANNEL_MAX;
+  }
+}
 #endif
 
 void ADCSensor::setup() {
@@ -21,7 +44,9 @@ void ADCSensor::setup() {
 #endif
 
 #ifdef ARDUINO_ARCH_ESP32
-  analogSetPinAttenuation(this->pin_, this->attenuation_);
+  adc1_config_channel_atten(gpio_to_adc1(pin_), attenuation_);
+  adc1_config_width(ADC_WIDTH_BIT_12);
+  adc_gpio_init(ADC_UNIT_1, (adc_channel_t) gpio_to_adc1(pin_));
 #endif
 }
 void ADCSensor::dump_config() {
@@ -36,18 +61,20 @@ void ADCSensor::dump_config() {
 #ifdef ARDUINO_ARCH_ESP32
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       ESP_LOGCONFIG(TAG, " Attenuation: 0db (max 1.1V)");
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       ESP_LOGCONFIG(TAG, " Attenuation: 2.5db (max 1.5V)");
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       ESP_LOGCONFIG(TAG, " Attenuation: 6db (max 2.2V)");
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       ESP_LOGCONFIG(TAG, " Attenuation: 11db (max 3.9V)");
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
 #endif
   LOG_UPDATE_INTERVAL(this);
@@ -60,20 +87,23 @@ void ADCSensor::update() {
 }
 float ADCSensor::sample() {
 #ifdef ARDUINO_ARCH_ESP32
-  float value_v = analogRead(this->pin_) / 4095.0f;  // NOLINT
+  int raw = adc1_get_raw(gpio_to_adc1(pin_));
+  float value_v = raw / 4095.0f;
   switch (this->attenuation_) {
-    case ADC_0db:
+    case ADC_ATTEN_DB_0:
       value_v *= 1.1;
       break;
-    case ADC_2_5db:
+    case ADC_ATTEN_DB_2_5:
       value_v *= 1.5;
       break;
-    case ADC_6db:
+    case ADC_ATTEN_DB_6:
       value_v *= 2.2;
       break;
-    case ADC_11db:
+    case ADC_ATTEN_DB_11:
       value_v *= 3.9;
       break;
+    default:  // This is to satisfy the unused ADC_ATTEN_MAX
+      break;
   }
   return value_v;
 #endif

esphome/components/adc/adc_sensor.h

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

esphome/components/adc/sensor.py

@@ -16,10 +16,10 @@ from esphome.const import (
 AUTO_LOAD = ["voltage_sampler"]
 
 ATTENUATION_MODES = {
-    "0db": cg.global_ns.ADC_0db,
-    "2.5db": cg.global_ns.ADC_2_5db,
-    "6db": cg.global_ns.ADC_6db,
-    "11db": cg.global_ns.ADC_11db,
+    "0db": cg.global_ns.ADC_ATTEN_DB_0,
+    "2.5db": cg.global_ns.ADC_ATTEN_DB_2_5,
+    "6db": cg.global_ns.ADC_ATTEN_DB_6,
+    "11db": cg.global_ns.ADC_ATTEN_DB_11,
 }
 
 

esphome/components/addressable_light/addressable_light_display.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace addressable_light {
 
-static const char* TAG = "addressable_light.display";
+static const char *const TAG = "addressable_light.display";
 
 int AddressableLightDisplay::get_width_internal() { return this->width_; }
 int AddressableLightDisplay::get_height_internal() { return this->height_; }
@@ -24,7 +24,7 @@ void AddressableLightDisplay::update() {
 void AddressableLightDisplay::display() {
   bool dirty = false;
   uint8_t old_r, old_g, old_b, old_w;
-  Color* c;
+  Color *c;
 
   for (uint32_t offset = 0; offset < this->addressable_light_buffer_.size(); offset++) {
     c = &(this->addressable_light_buffer_[offset]);

esphome/components/ade7953/ade7953.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace ade7953 {
 
-static const char *TAG = "ade7953";
+static const char *const TAG = "ade7953";
 
 void ADE7953::dump_config() {
   ESP_LOGCONFIG(TAG, "ADE7953:");
@@ -21,8 +21,8 @@ void ADE7953::dump_config() {
 }
 
 #define ADE_PUBLISH_(name, factor) \
-  if (name && this->name##_sensor_) { \
-    float value = *name / factor; \
+  if ((name) && this->name##_sensor_) { \
+    float value = *(name) / (factor); \
     this->name##_sensor_->publish_state(value); \
   }
 #define ADE_PUBLISH(name, factor) ADE_PUBLISH_(name, factor)

esphome/components/ads1115/ads1115.cpp

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

esphome/components/aht10/aht10.cpp

@@ -18,7 +18,7 @@
 namespace esphome {
 namespace aht10 {
 
-static const char *TAG = "aht10";
+static const char *const TAG = "aht10";
 static const uint8_t AHT10_CALIBRATE_CMD[] = {0xE1};
 static const uint8_t AHT10_MEASURE_CMD[] = {0xAC, 0x33, 0x00};
 static const uint8_t AHT10_DEFAULT_DELAY = 5;    // ms, for calibration and temperature measurement

esphome/components/am2320/am2320.cpp

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

esphome/components/anova/anova.cpp

@@ -0,0 +1,141 @@
+#include "anova.h"
+#include "esphome/core/log.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+namespace esphome {
+namespace anova {
+
+static const char *TAG = "anova";
+
+using namespace esphome::climate;
+
+void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
+
+void Anova::setup() {
+  this->codec_ = new AnovaCodec();
+  this->current_request_ = 0;
+}
+
+void Anova::loop() {}
+
+void Anova::control(const ClimateCall &call) {
+  if (call.get_mode().has_value()) {
+    ClimateMode mode = *call.get_mode();
+    AnovaPacket *pkt;
+    switch (mode) {
+      case climate::CLIMATE_MODE_OFF:
+        pkt = this->codec_->get_stop_request();
+        break;
+      case climate::CLIMATE_MODE_HEAT:
+        pkt = this->codec_->get_start_request();
+        break;
+      default:
+        ESP_LOGW(TAG, "Unsupported mode: %d", mode);
+        return;
+    }
+    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
+                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status)
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+  }
+  if (call.get_target_temperature().has_value()) {
+    auto pkt = this->codec_->get_set_target_temp_request(*call.get_target_temperature());
+    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
+                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status)
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+  }
+}
+
+void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_DISCONNECT_EVT: {
+      this->current_temperature = NAN;
+      this->target_temperature = NAN;
+      this->publish_state();
+      break;
+    }
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      auto chr = this->parent_->get_characteristic(ANOVA_SERVICE_UUID, ANOVA_CHARACTERISTIC_UUID);
+      if (chr == nullptr) {
+        ESP_LOGW(TAG, "[%s] No control service found at device, not an Anova..?", this->get_name().c_str());
+        ESP_LOGW(TAG, "[%s] Note, this component does not currently support Anova Nano.", this->get_name().c_str());
+        break;
+      }
+      this->char_handle_ = chr->handle;
+
+      auto status = esp_ble_gattc_register_for_notify(this->parent_->gattc_if, this->parent_->remote_bda, chr->handle);
+      if (status) {
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
+      }
+      break;
+    }
+    case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
+      this->node_state = espbt::ClientState::Established;
+      this->current_request_ = 0;
+      this->update();
+      break;
+    }
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.handle != this->char_handle_)
+        break;
+      this->codec_->decode(param->notify.value, param->notify.value_len);
+      if (this->codec_->has_target_temp()) {
+        this->target_temperature = this->codec_->target_temp_;
+      }
+      if (this->codec_->has_current_temp()) {
+        this->current_temperature = this->codec_->current_temp_;
+      }
+      if (this->codec_->has_running()) {
+        this->mode = this->codec_->running_ ? climate::CLIMATE_MODE_HEAT : climate::CLIMATE_MODE_OFF;
+      }
+      this->publish_state();
+
+      if (this->current_request_ > 0) {
+        AnovaPacket *pkt = nullptr;
+        switch (this->current_request_++) {
+          case 1:
+            pkt = this->codec_->get_read_target_temp_request();
+            break;
+          case 2:
+            pkt = this->codec_->get_read_current_temp_request();
+            break;
+          default:
+            this->current_request_ = 0;
+            break;
+        }
+        if (pkt != nullptr) {
+          auto status =
+              esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, pkt->length,
+                                       pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+          if (status)
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(),
+                     status);
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void Anova::update() {
+  if (this->node_state != espbt::ClientState::Established)
+    return;
+
+  if (this->current_request_ == 0) {
+    auto pkt = this->codec_->get_read_device_status_request();
+    auto status = esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_,
+                                           pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status)
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str().c_str(), status);
+    this->current_request_++;
+  }
+}
+
+}  // namespace anova
+}  // namespace esphome
+
+#endif

esphome/components/anova/anova.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/ble_client/ble_client.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#include "esphome/components/climate/climate.h"
+#include "anova_base.h"
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include <esp_gattc_api.h>
+
+namespace esphome {
+namespace anova {
+
+namespace espbt = esphome::esp32_ble_tracker;
+
+static const uint16_t ANOVA_SERVICE_UUID = 0xFFE0;
+static const uint16_t ANOVA_CHARACTERISTIC_UUID = 0xFFE1;
+
+class Anova : public climate::Climate, public esphome::ble_client::BLEClientNode, public PollingComponent {
+ public:
+  void setup() override;
+  void loop() override;
+  void update() override;
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  climate::ClimateTraits traits() {
+    auto traits = climate::ClimateTraits();
+    traits.set_supports_current_temperature(true);
+    traits.set_supports_heat_mode(true);
+    traits.set_visual_min_temperature(25.0);
+    traits.set_visual_max_temperature(100.0);
+    traits.set_visual_temperature_step(0.1);
+    return traits;
+  }
+
+ protected:
+  AnovaCodec *codec_;
+  void control(const climate::ClimateCall &call) override;
+  uint16_t char_handle_;
+  uint8_t current_request_;
+};
+
+}  // namespace anova
+}  // namespace esphome
+
+#endif

esphome/components/anova/anova_base.cpp

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

esphome/components/anova/anova_base.h

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

esphome/components/anova/climate.py

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

esphome/components/apds9960/apds9960.cpp

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

esphome/components/api/api.proto

@@ -38,6 +38,7 @@ service APIConnection {
   rpc switch_command (SwitchCommandRequest) returns (void) {}
   rpc camera_image (CameraImageRequest) returns (void) {}
   rpc climate_command (ClimateCommandRequest) returns (void) {}
+  rpc number_command (NumberCommandRequest) returns (void) {}
 }
 
 
@@ -378,6 +379,7 @@ message LightStateResponse {
   fixed32 key = 1;
   bool state = 2;
   float brightness = 3;
+  float color_brightness = 10;
   float red = 4;
   float green = 5;
   float blue = 6;
@@ -396,6 +398,8 @@ message LightCommandRequest {
   bool state = 3;
   bool has_brightness = 4;
   float brightness = 5;
+  bool has_color_brightness = 20;
+  float color_brightness = 21;
   bool has_rgb = 6;
   float red = 7;
   float green = 8;
@@ -418,6 +422,12 @@ enum SensorStateClass {
   STATE_CLASS_MEASUREMENT = 1;
 }
 
+enum SensorLastResetType {
+  LAST_RESET_NONE = 0;
+  LAST_RESET_NEVER = 1;
+  LAST_RESET_AUTO = 2;
+}
+
 message ListEntitiesSensorResponse {
   option (id) = 16;
   option (source) = SOURCE_SERVER;
@@ -434,6 +444,7 @@ message ListEntitiesSensorResponse {
   bool force_update = 8;
   string device_class = 9;
   SensorStateClass state_class = 10;
+  SensorLastResetType last_reset_type = 11;
 }
 message SensorStateResponse {
   option (id) = 25;
@@ -710,13 +721,14 @@ enum ClimateAction {
   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;
+  CLIMATE_PRESET_NONE = 0;
+  CLIMATE_PRESET_HOME = 1;
+  CLIMATE_PRESET_AWAY = 2;
+  CLIMATE_PRESET_BOOST = 3;
+  CLIMATE_PRESET_COMFORT = 4;
+  CLIMATE_PRESET_ECO = 5;
+  CLIMATE_PRESET_SLEEP = 6;
+  CLIMATE_PRESET_ACTIVITY = 7;
 }
 message ListEntitiesClimateResponse {
   option (id) = 46;
@@ -734,7 +746,9 @@ message ListEntitiesClimateResponse {
   float visual_min_temperature = 8;
   float visual_max_temperature = 9;
   float visual_temperature_step = 10;
-  bool supports_away = 11;
+  // for older peer versions - in new system this
+  // is if CLIMATE_PRESET_AWAY exists is supported_presets
+  bool legacy_supports_away = 11;
   bool supports_action = 12;
   repeated ClimateFanMode supported_fan_modes = 13;
   repeated ClimateSwingMode supported_swing_modes = 14;
@@ -754,7 +768,8 @@ message ClimateStateResponse {
   float target_temperature = 4;
   float target_temperature_low = 5;
   float target_temperature_high = 6;
-  bool away = 7;
+  // For older peers, equal to preset == CLIMATE_PRESET_AWAY
+  bool legacy_away = 7;
   ClimateAction action = 8;
   ClimateFanMode fan_mode = 9;
   ClimateSwingMode swing_mode = 10;
@@ -777,8 +792,9 @@ message ClimateCommandRequest {
   float target_temperature_low = 7;
   bool has_target_temperature_high = 8;
   float target_temperature_high = 9;
-  bool has_away = 10;
-  bool away = 11;
+  // legacy, for older peers, newer ones should use CLIMATE_PRESET_AWAY in preset
+  bool has_legacy_away = 10;
+  bool legacy_away = 11;
   bool has_fan_mode = 12;
   ClimateFanMode fan_mode = 13;
   bool has_swing_mode = 14;
@@ -790,3 +806,41 @@ message ClimateCommandRequest {
   bool has_custom_preset = 20;
   string custom_preset = 21;
 }
+
+// ==================== NUMBER ====================
+message ListEntitiesNumberResponse {
+  option (id) = 49;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_NUMBER";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  float min_value = 6;
+  float max_value = 7;
+  float step = 8;
+}
+message NumberStateResponse {
+  option (id) = 50;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_NUMBER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float state = 2;
+  // If the number does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 3;
+}
+message NumberCommandRequest {
+  option (id) = 51;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_NUMBER";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float state = 2;
+}

esphome/components/api/api_connection.cpp

@@ -16,7 +16,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.connection";
+static const char *const TAG = "api.connection";
 
 APIConnection::APIConnection(AsyncClient *client, APIServer *parent)
     : client_(client), parent_(parent), initial_state_iterator_(parent, this), list_entities_iterator_(parent, this) {
@@ -308,6 +308,7 @@ bool APIConnection::send_light_state(light::LightState *light) {
   if (traits.get_supports_brightness())
     resp.brightness = values.get_brightness();
   if (traits.get_supports_rgb()) {
+    resp.color_brightness = values.get_color_brightness();
     resp.red = values.get_red();
     resp.green = values.get_green();
     resp.blue = values.get_blue();
@@ -352,6 +353,8 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
     call.set_state(msg.state);
   if (msg.has_brightness)
     call.set_brightness(msg.brightness);
+  if (msg.has_color_brightness)
+    call.set_color_brightness(msg.color_brightness);
   if (msg.has_rgb) {
     call.set_red(msg.red);
     call.set_green(msg.green);
@@ -396,6 +399,7 @@ bool APIConnection::send_sensor_info(sensor::Sensor *sensor) {
   msg.force_update = sensor->get_force_update();
   msg.device_class = sensor->get_device_class();
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->state_class);
+  msg.last_reset_type = static_cast<enums::SensorLastResetType>(sensor->last_reset_type);
 
   return this->send_list_entities_sensor_response(msg);
 }
@@ -475,14 +479,14 @@ bool APIConnection::send_climate_state(climate::Climate *climate) {
   } else {
     resp.target_temperature = climate->target_temperature;
   }
-  if (traits.get_supports_away())
-    resp.away = climate->away;
   if (traits.get_supports_fan_modes() && 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())
+  if (traits.get_supports_presets() && climate->preset.has_value()) {
     resp.preset = static_cast<enums::ClimatePreset>(climate->preset.value());
+    resp.legacy_away = resp.preset == enums::CLIMATE_PRESET_AWAY;
+  }
   if (!traits.get_supported_custom_presets().empty() && climate->custom_preset.has_value())
     resp.custom_preset = climate->custom_preset.value();
   if (traits.get_supports_swing_modes())
@@ -498,40 +502,26 @@ bool APIConnection::send_climate_info(climate::Climate *climate) {
   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));
-  }
+
+  for (auto mode : traits.get_supported_modes())
+    msg.supported_modes.push_back(static_cast<enums::ClimateMode>(mode));
+
   msg.visual_min_temperature = traits.get_visual_min_temperature();
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_temperature_step = traits.get_visual_temperature_step();
-  msg.supports_away = traits.get_supports_away();
+  msg.legacy_supports_away = traits.supports_preset(climate::CLIMATE_PRESET_AWAY);
   msg.supports_action = traits.get_supports_action();
-  for (auto fan_mode : {climate::CLIMATE_FAN_ON, climate::CLIMATE_FAN_OFF, climate::CLIMATE_FAN_AUTO,
-                        climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
-                        climate::CLIMATE_FAN_MIDDLE, climate::CLIMATE_FAN_FOCUS, climate::CLIMATE_FAN_DIFFUSE}) {
-    if (traits.supports_fan_mode(fan_mode))
-      msg.supported_fan_modes.push_back(static_cast<enums::ClimateFanMode>(fan_mode));
-  }
-  for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes()) {
+
+  for (auto fan_mode : traits.get_supported_fan_modes())
+    msg.supported_fan_modes.push_back(static_cast<enums::ClimateFanMode>(fan_mode));
+  for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes())
     msg.supported_custom_fan_modes.push_back(custom_fan_mode);
-  }
-  for (auto preset : {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()) {
+  for (auto preset : traits.get_supported_presets())
+    msg.supported_presets.push_back(static_cast<enums::ClimatePreset>(preset));
+  for (auto const &custom_preset : traits.get_supported_custom_presets())
     msg.supported_custom_presets.push_back(custom_preset);
-  }
-  for (auto swing_mode : {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_BOTH, climate::CLIMATE_SWING_VERTICAL,
-                          climate::CLIMATE_SWING_HORIZONTAL}) {
-    if (traits.supports_swing_mode(swing_mode))
-      msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
-  }
+  for (auto swing_mode : traits.get_supported_swing_modes())
+    msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
   return this->send_list_entities_climate_response(msg);
 }
 void APIConnection::climate_command(const ClimateCommandRequest &msg) {
@@ -548,8 +538,8 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
     call.set_target_temperature_low(msg.target_temperature_low);
   if (msg.has_target_temperature_high)
     call.set_target_temperature_high(msg.target_temperature_high);
-  if (msg.has_away)
-    call.set_away(msg.away);
+  if (msg.has_legacy_away)
+    call.set_preset(msg.legacy_away ? climate::CLIMATE_PRESET_AWAY : climate::CLIMATE_PRESET_HOME);
   if (msg.has_fan_mode)
     call.set_fan_mode(static_cast<climate::ClimateFanMode>(msg.fan_mode));
   if (msg.has_custom_fan_mode)
@@ -564,6 +554,42 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_NUMBER
+bool APIConnection::send_number_state(number::Number *number, float state) {
+  if (!this->state_subscription_)
+    return false;
+
+  NumberStateResponse resp{};
+  resp.key = number->get_object_id_hash();
+  resp.state = state;
+  resp.missing_state = !number->has_state();
+  return this->send_number_state_response(resp);
+}
+bool APIConnection::send_number_info(number::Number *number) {
+  ListEntitiesNumberResponse msg;
+  msg.key = number->get_object_id_hash();
+  msg.object_id = number->get_object_id();
+  msg.name = number->get_name();
+  msg.unique_id = get_default_unique_id("number", number);
+  msg.icon = number->traits.get_icon();
+
+  msg.min_value = number->traits.get_min_value();
+  msg.max_value = number->traits.get_max_value();
+  msg.step = number->traits.get_step();
+
+  return this->send_list_entities_number_response(msg);
+}
+void APIConnection::number_command(const NumberCommandRequest &msg) {
+  number::Number *number = App.get_number_by_key(msg.key);
+  if (number == nullptr)
+    return;
+
+  auto call = number->make_call();
+  call.set_value(msg.state);
+  call.perform();
+}
+#endif
+
 #ifdef USE_ESP32_CAMERA
 void APIConnection::send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
   if (!this->state_subscription_)
@@ -629,7 +655,7 @@ HelloResponse APIConnection::hello(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 4;
+  resp.api_version_minor = 5;
   resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
   this->connection_state_ = ConnectionState::CONNECTED;
   return resp;

esphome/components/api/api_connection.h

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

esphome/components/api/api_pb2.cpp

@@ -72,6 +72,18 @@ template<> const char *proto_enum_to_string<enums::SensorStateClass>(enums::Sens
       return "UNKNOWN";
   }
 }
+template<> const char *proto_enum_to_string<enums::SensorLastResetType>(enums::SensorLastResetType value) {
+  switch (value) {
+    case enums::LAST_RESET_NONE:
+      return "LAST_RESET_NONE";
+    case enums::LAST_RESET_NEVER:
+      return "LAST_RESET_NEVER";
+    case enums::LAST_RESET_AUTO:
+      return "LAST_RESET_AUTO";
+    default:
+      return "UNKNOWN";
+  }
+}
 template<> const char *proto_enum_to_string<enums::LogLevel>(enums::LogLevel value) {
   switch (value) {
     case enums::LOG_LEVEL_NONE:
@@ -192,16 +204,18 @@ template<> const char *proto_enum_to_string<enums::ClimateAction>(enums::Climate
 }
 template<> const char *proto_enum_to_string<enums::ClimatePreset>(enums::ClimatePreset value) {
   switch (value) {
-    case enums::CLIMATE_PRESET_ECO:
-      return "CLIMATE_PRESET_ECO";
+    case enums::CLIMATE_PRESET_NONE:
+      return "CLIMATE_PRESET_NONE";
+    case enums::CLIMATE_PRESET_HOME:
+      return "CLIMATE_PRESET_HOME";
     case enums::CLIMATE_PRESET_AWAY:
       return "CLIMATE_PRESET_AWAY";
     case enums::CLIMATE_PRESET_BOOST:
       return "CLIMATE_PRESET_BOOST";
     case enums::CLIMATE_PRESET_COMFORT:
       return "CLIMATE_PRESET_COMFORT";
-    case enums::CLIMATE_PRESET_HOME:
-      return "CLIMATE_PRESET_HOME";
+    case enums::CLIMATE_PRESET_ECO:
+      return "CLIMATE_PRESET_ECO";
     case enums::CLIMATE_PRESET_SLEEP:
       return "CLIMATE_PRESET_SLEEP";
     case enums::CLIMATE_PRESET_ACTIVITY:
@@ -1261,6 +1275,10 @@ bool LightStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->brightness = value.as_float();
       return true;
     }
+    case 10: {
+      this->color_brightness = value.as_float();
+      return true;
+    }
     case 4: {
       this->red = value.as_float();
       return true;
@@ -1289,6 +1307,7 @@ void LightStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
   buffer.encode_bool(2, this->state);
   buffer.encode_float(3, this->brightness);
+  buffer.encode_float(10, this->color_brightness);
   buffer.encode_float(4, this->red);
   buffer.encode_float(5, this->green);
   buffer.encode_float(6, this->blue);
@@ -1313,6 +1332,11 @@ void LightStateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  color_brightness: ");
+  sprintf(buffer, "%g", this->color_brightness);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  red: ");
   sprintf(buffer, "%g", this->red);
   out.append(buffer);
@@ -1357,6 +1381,10 @@ bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
       this->has_brightness = value.as_bool();
       return true;
     }
+    case 20: {
+      this->has_color_brightness = value.as_bool();
+      return true;
+    }
     case 6: {
       this->has_rgb = value.as_bool();
       return true;
@@ -1413,6 +1441,10 @@ bool LightCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
       this->brightness = value.as_float();
       return true;
     }
+    case 21: {
+      this->color_brightness = value.as_float();
+      return true;
+    }
     case 7: {
       this->red = value.as_float();
       return true;
@@ -1443,6 +1475,8 @@ void LightCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->state);
   buffer.encode_bool(4, this->has_brightness);
   buffer.encode_float(5, this->brightness);
+  buffer.encode_bool(20, this->has_color_brightness);
+  buffer.encode_float(21, this->color_brightness);
   buffer.encode_bool(6, this->has_rgb);
   buffer.encode_float(7, this->red);
   buffer.encode_float(8, this->green);
@@ -1483,6 +1517,15 @@ void LightCommandRequest::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
+  out.append("  has_color_brightness: ");
+  out.append(YESNO(this->has_color_brightness));
+  out.append("\n");
+
+  out.append("  color_brightness: ");
+  sprintf(buffer, "%g", this->color_brightness);
+  out.append(buffer);
+  out.append("\n");
+
   out.append("  has_rgb: ");
   out.append(YESNO(this->has_rgb));
   out.append("\n");
@@ -1561,6 +1604,10 @@ bool ListEntitiesSensorResponse::decode_varint(uint32_t field_id, ProtoVarInt va
       this->state_class = value.as_enum<enums::SensorStateClass>();
       return true;
     }
+    case 11: {
+      this->last_reset_type = value.as_enum<enums::SensorLastResetType>();
+      return true;
+    }
     default:
       return false;
   }
@@ -1616,6 +1663,7 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(8, this->force_update);
   buffer.encode_string(9, this->device_class);
   buffer.encode_enum<enums::SensorStateClass>(10, this->state_class);
+  buffer.encode_enum<enums::SensorLastResetType>(11, this->last_reset_type);
 }
 void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   char buffer[64];
@@ -1661,6 +1709,10 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   out.append("  state_class: ");
   out.append(proto_enum_to_string<enums::SensorStateClass>(this->state_class));
   out.append("\n");
+
+  out.append("  last_reset_type: ");
+  out.append(proto_enum_to_string<enums::SensorLastResetType>(this->last_reset_type));
+  out.append("\n");
   out.append("}");
 }
 bool SensorStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -2672,7 +2724,7 @@ bool ListEntitiesClimateResponse::decode_varint(uint32_t field_id, ProtoVarInt v
       return true;
     }
     case 11: {
-      this->supports_away = value.as_bool();
+      this->legacy_supports_away = value.as_bool();
       return true;
     }
     case 12: {
@@ -2756,7 +2808,7 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(8, this->visual_min_temperature);
   buffer.encode_float(9, this->visual_max_temperature);
   buffer.encode_float(10, this->visual_temperature_step);
-  buffer.encode_bool(11, this->supports_away);
+  buffer.encode_bool(11, this->legacy_supports_away);
   buffer.encode_bool(12, this->supports_action);
   for (auto &it : this->supported_fan_modes) {
     buffer.encode_enum<enums::ClimateFanMode>(13, it, true);
@@ -2823,8 +2875,8 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  supports_away: ");
-  out.append(YESNO(this->supports_away));
+  out.append("  legacy_supports_away: ");
+  out.append(YESNO(this->legacy_supports_away));
   out.append("\n");
 
   out.append("  supports_action: ");
@@ -2869,7 +2921,7 @@ bool ClimateStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       return true;
     }
     case 7: {
-      this->away = value.as_bool();
+      this->legacy_away = value.as_bool();
       return true;
     }
     case 8: {
@@ -2939,7 +2991,7 @@ void ClimateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(4, this->target_temperature);
   buffer.encode_float(5, this->target_temperature_low);
   buffer.encode_float(6, this->target_temperature_high);
-  buffer.encode_bool(7, this->away);
+  buffer.encode_bool(7, this->legacy_away);
   buffer.encode_enum<enums::ClimateAction>(8, this->action);
   buffer.encode_enum<enums::ClimateFanMode>(9, this->fan_mode);
   buffer.encode_enum<enums::ClimateSwingMode>(10, this->swing_mode);
@@ -2979,8 +3031,8 @@ void ClimateStateResponse::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  away: ");
-  out.append(YESNO(this->away));
+  out.append("  legacy_away: ");
+  out.append(YESNO(this->legacy_away));
   out.append("\n");
 
   out.append("  action: ");
@@ -3031,11 +3083,11 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
       return true;
     }
     case 10: {
-      this->has_away = value.as_bool();
+      this->has_legacy_away = value.as_bool();
       return true;
     }
     case 11: {
-      this->away = value.as_bool();
+      this->legacy_away = value.as_bool();
       return true;
     }
     case 12: {
@@ -3120,8 +3172,8 @@ void ClimateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(7, this->target_temperature_low);
   buffer.encode_bool(8, this->has_target_temperature_high);
   buffer.encode_float(9, this->target_temperature_high);
-  buffer.encode_bool(10, this->has_away);
-  buffer.encode_bool(11, this->away);
+  buffer.encode_bool(10, this->has_legacy_away);
+  buffer.encode_bool(11, this->legacy_away);
   buffer.encode_bool(12, this->has_fan_mode);
   buffer.encode_enum<enums::ClimateFanMode>(13, this->fan_mode);
   buffer.encode_bool(14, this->has_swing_mode);
@@ -3176,12 +3228,12 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   out.append(buffer);
   out.append("\n");
 
-  out.append("  has_away: ");
-  out.append(YESNO(this->has_away));
+  out.append("  has_legacy_away: ");
+  out.append(YESNO(this->has_legacy_away));
   out.append("\n");
 
-  out.append("  away: ");
-  out.append(YESNO(this->away));
+  out.append("  legacy_away: ");
+  out.append(YESNO(this->legacy_away));
   out.append("\n");
 
   out.append("  has_fan_mode: ");
@@ -3225,6 +3277,179 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   out.append("\n");
   out.append("}");
 }
+bool ListEntitiesNumberResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesNumberResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 6: {
+      this->min_value = value.as_float();
+      return true;
+    }
+    case 7: {
+      this->max_value = value.as_float();
+      return true;
+    }
+    case 8: {
+      this->step = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->object_id);
+  buffer.encode_fixed32(2, this->key);
+  buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
+  buffer.encode_string(5, this->icon);
+  buffer.encode_float(6, this->min_value);
+  buffer.encode_float(7, this->max_value);
+  buffer.encode_float(8, this->step);
+}
+void ListEntitiesNumberResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("ListEntitiesNumberResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  name: ");
+  out.append("'").append(this->name).append("'");
+  out.append("\n");
+
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
+  out.append("  icon: ");
+  out.append("'").append(this->icon).append("'");
+  out.append("\n");
+
+  out.append("  min_value: ");
+  sprintf(buffer, "%g", this->min_value);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  max_value: ");
+  sprintf(buffer, "%g", this->max_value);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  step: ");
+  sprintf(buffer, "%g", this->step);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+bool NumberStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 3: {
+      this->missing_state = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool NumberStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 2: {
+      this->state = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NumberStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->state);
+  buffer.encode_bool(3, this->missing_state);
+}
+void NumberStateResponse::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("NumberStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  sprintf(buffer, "%g", this->state);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  missing_state: ");
+  out.append(YESNO(this->missing_state));
+  out.append("\n");
+  out.append("}");
+}
+bool NumberCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 2: {
+      this->state = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void NumberCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->state);
+}
+void NumberCommandRequest::dump_to(std::string &out) const {
+  char buffer[64];
+  out.append("NumberCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%u", this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  state: ");
+  sprintf(buffer, "%g", this->state);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -36,6 +36,11 @@ enum SensorStateClass : uint32_t {
   STATE_CLASS_NONE = 0,
   STATE_CLASS_MEASUREMENT = 1,
 };
+enum SensorLastResetType : uint32_t {
+  LAST_RESET_NONE = 0,
+  LAST_RESET_NEVER = 1,
+  LAST_RESET_AUTO = 2,
+};
 enum LogLevel : uint32_t {
   LOG_LEVEL_NONE = 0,
   LOG_LEVEL_ERROR = 1,
@@ -90,13 +95,14 @@ enum ClimateAction : uint32_t {
   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,
+  CLIMATE_PRESET_NONE = 0,
+  CLIMATE_PRESET_HOME = 1,
+  CLIMATE_PRESET_AWAY = 2,
+  CLIMATE_PRESET_BOOST = 3,
+  CLIMATE_PRESET_COMFORT = 4,
+  CLIMATE_PRESET_ECO = 5,
+  CLIMATE_PRESET_SLEEP = 6,
+  CLIMATE_PRESET_ACTIVITY = 7,
 };
 
 }  // namespace enums
@@ -370,6 +376,7 @@ class LightStateResponse : public ProtoMessage {
   uint32_t key{0};
   bool state{false};
   float brightness{0.0f};
+  float color_brightness{0.0f};
   float red{0.0f};
   float green{0.0f};
   float blue{0.0f};
@@ -391,6 +398,8 @@ class LightCommandRequest : public ProtoMessage {
   bool state{false};
   bool has_brightness{false};
   float brightness{0.0f};
+  bool has_color_brightness{false};
+  float color_brightness{0.0f};
   bool has_rgb{false};
   float red{0.0f};
   float green{0.0f};
@@ -425,6 +434,7 @@ class ListEntitiesSensorResponse : public ProtoMessage {
   bool force_update{false};
   std::string device_class{};
   enums::SensorStateClass state_class{};
+  enums::SensorLastResetType last_reset_type{};
   void encode(ProtoWriteBuffer buffer) const override;
   void dump_to(std::string &out) const override;
 
@@ -709,7 +719,7 @@ class ListEntitiesClimateResponse : public ProtoMessage {
   float visual_min_temperature{0.0f};
   float visual_max_temperature{0.0f};
   float visual_temperature_step{0.0f};
-  bool supports_away{false};
+  bool legacy_supports_away{false};
   bool supports_action{false};
   std::vector<enums::ClimateFanMode> supported_fan_modes{};
   std::vector<enums::ClimateSwingMode> supported_swing_modes{};
@@ -732,7 +742,7 @@ class ClimateStateResponse : public ProtoMessage {
   float target_temperature{0.0f};
   float target_temperature_low{0.0f};
   float target_temperature_high{0.0f};
-  bool away{false};
+  bool legacy_away{false};
   enums::ClimateAction action{};
   enums::ClimateFanMode fan_mode{};
   enums::ClimateSwingMode swing_mode{};
@@ -758,8 +768,8 @@ class ClimateCommandRequest : public ProtoMessage {
   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_legacy_away{false};
+  bool legacy_away{false};
   bool has_fan_mode{false};
   enums::ClimateFanMode fan_mode{};
   bool has_swing_mode{false};
@@ -778,6 +788,45 @@ class ClimateCommandRequest : public ProtoMessage {
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class ListEntitiesNumberResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  float min_value{0.0f};
+  float max_value{0.0f};
+  float step{0.0f};
+  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 NumberStateResponse : 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 NumberCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  float state{0.0f};
+  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;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.service";
+static const char *const TAG = "api.service";
 
 bool APIServerConnectionBase::send_hello_response(const HelloResponse &msg) {
   ESP_LOGVV(TAG, "send_hello_response: %s", msg.dump().c_str());
@@ -184,6 +184,20 @@ bool APIServerConnectionBase::send_climate_state_response(const ClimateStateResp
 #endif
 #ifdef USE_CLIMATE
 #endif
+#ifdef USE_NUMBER
+bool APIServerConnectionBase::send_list_entities_number_response(const ListEntitiesNumberResponse &msg) {
+  ESP_LOGVV(TAG, "send_list_entities_number_response: %s", msg.dump().c_str());
+  return this->send_message_<ListEntitiesNumberResponse>(msg, 49);
+}
+#endif
+#ifdef USE_NUMBER
+bool APIServerConnectionBase::send_number_state_response(const NumberStateResponse &msg) {
+  ESP_LOGVV(TAG, "send_number_state_response: %s", msg.dump().c_str());
+  return this->send_message_<NumberStateResponse>(msg, 50);
+}
+#endif
+#ifdef USE_NUMBER
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -349,6 +363,15 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       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;
+    }
+    case 51: {
+#ifdef USE_NUMBER
+      NumberCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+      ESP_LOGVV(TAG, "on_number_command_request: %s", msg.dump().c_str());
+      this->on_number_command_request(msg);
 #endif
       break;
     }
@@ -547,6 +570,19 @@ void APIServerConnection::on_climate_command_request(const ClimateCommandRequest
   this->climate_command(msg);
 }
 #endif
+#ifdef USE_NUMBER
+void APIServerConnection::on_number_command_request(const NumberCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->number_command(msg);
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.h

@@ -111,6 +111,15 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_CLIMATE
   virtual void on_climate_command_request(const ClimateCommandRequest &value){};
+#endif
+#ifdef USE_NUMBER
+  bool send_list_entities_number_response(const ListEntitiesNumberResponse &msg);
+#endif
+#ifdef USE_NUMBER
+  bool send_number_state_response(const NumberStateResponse &msg);
+#endif
+#ifdef USE_NUMBER
+  virtual void on_number_command_request(const NumberCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -147,6 +156,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #endif
 #ifdef USE_CLIMATE
   virtual void climate_command(const ClimateCommandRequest &msg) = 0;
+#endif
+#ifdef USE_NUMBER
+  virtual void number_command(const NumberCommandRequest &msg) = 0;
 #endif
  protected:
   void on_hello_request(const HelloRequest &msg) override;
@@ -179,6 +191,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_CLIMATE
   void on_climate_command_request(const ClimateCommandRequest &msg) override;
 #endif
+#ifdef USE_NUMBER
+  void on_number_command_request(const NumberCommandRequest &msg) override;
+#endif
 };
 
 }  // namespace api

esphome/components/api/api_server.cpp

@@ -15,7 +15,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api";
+static const char *const TAG = "api";
 
 // APIServer
 void APIServer::setup() {
@@ -180,7 +180,7 @@ void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
 #endif
 
 #ifdef USE_TEXT_SENSOR
-void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, std::string state) {
+void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
   if (obj->is_internal())
     return;
   for (auto *c : this->clients_)
@@ -197,9 +197,18 @@ void APIServer::on_climate_update(climate::Climate *obj) {
 }
 #endif
 
+#ifdef USE_NUMBER
+void APIServer::on_number_update(number::Number *obj, float state) {
+  if (obj->is_internal())
+    return;
+  for (auto *c : this->clients_)
+    c->send_number_state(obj, state);
+}
+#endif
+
 float APIServer::get_setup_priority() const { return setup_priority::AFTER_WIFI; }
 void APIServer::set_port(uint16_t port) { this->port_ = port; }
-APIServer *global_api_server = nullptr;
+APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void APIServer::set_password(const std::string &password) { this->password_ = password; }
 void APIServer::send_homeassistant_service_call(const HomeassistantServiceResponse &call) {

esphome/components/api/api_server.h

@@ -56,10 +56,13 @@ class APIServer : public Component, public Controller {
   void on_switch_update(switch_::Switch *obj, bool state) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj, std::string state) override;
+  void on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) override;
 #endif
 #ifdef USE_CLIMATE
   void on_climate_update(climate::Climate *obj) override;
+#endif
+#ifdef USE_NUMBER
+  void on_number_update(number::Number *obj, float state) override;
 #endif
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
@@ -91,7 +94,7 @@ class APIServer : public Component, public Controller {
   std::vector<UserServiceDescriptor *> user_services_;
 };
 
-extern APIServer *global_api_server;
+extern APIServer *global_api_server;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 template<typename... Ts> class APIConnectedCondition : public Condition<Ts...> {
  public:

esphome/components/api/list_entities.cpp

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

esphome/components/api/list_entities.h

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

esphome/components/api/proto.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace api {
 
-static const char *TAG = "api.proto";
+static const char *const TAG = "api.proto";
 
 void ProtoMessage::decode(const uint8_t *buffer, size_t length) {
   uint32_t i = 0;

esphome/components/api/subscribe_state.cpp

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

esphome/components/api/subscribe_state.h

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

esphome/components/api/user_services.h

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

esphome/components/api/util.cpp

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

esphome/components/api/util.h

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

esphome/components/as3935/as3935.cpp

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

esphome/components/as3935_i2c/as3935_i2c.cpp

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

esphome/components/as3935_spi/as3935_spi.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace as3935_spi {
 
-static const char *TAG = "as3935_spi";
+static const char *const TAG = "as3935_spi";
 
 void SPIAS3935Component::setup() {
   ESP_LOGI(TAG, "SPIAS3935Component setup started!");

esphome/components/atc_mithermometer/atc_mithermometer.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace atc_mithermometer {
 
-static const char *TAG = "atc_mithermometer";
+static const char *const TAG = "atc_mithermometer";
 
 void ATCMiThermometer::dump_config() {
   ESP_LOGCONFIG(TAG, "ATC MiThermometer");

esphome/components/atm90e32/atm90e32.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace atm90e32 {
 
-static const char *TAG = "atm90e32";
+static const char *const TAG = "atm90e32";
 
 void ATM90E32Component::update() {
   if (this->read16_(ATM90E32_REGISTER_METEREN) != 1) {

esphome/components/atm90e32/sensor.py

@@ -21,6 +21,7 @@ from esphome.const import (
     ICON_EMPTY,
     ICON_LIGHTBULB,
     ICON_CURRENT_AC,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
     UNIT_HERTZ,
     UNIT_VOLT,
@@ -91,10 +92,20 @@ ATM90E32_PHASE_SCHEMA = cv.Schema(
             STATE_CLASS_MEASUREMENT,
         ),
         cv.Optional(CONF_FORWARD_ACTIVE_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            2,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_REVERSE_ACTIVE_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 2, DEVICE_CLASS_ENERGY, STATE_CLASS_MEASUREMENT
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            2,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_GAIN_VOLTAGE, default=7305): cv.uint16_t,
         cv.Optional(CONF_GAIN_CT, default=27961): cv.uint16_t,

esphome/components/b_parasite/b_parasite.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace b_parasite {
 
-static const char* TAG = "b_parasite";
+static const char *const TAG = "b_parasite";
 
 void BParasite::dump_config() {
   ESP_LOGCONFIG(TAG, "b_parasite");
@@ -16,25 +16,25 @@ void BParasite::dump_config() {
   LOG_SENSOR("  ", "Soil Moisture", this->soil_moisture_);
 }
 
-bool BParasite::parse_device(const esp32_ble_tracker::ESPBTDevice& device) {
+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();
+  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];
+  const auto &service_data = service_datas[0];
 
   ESP_LOGVV(TAG, "Service data:");
   for (const uint8_t byte : service_data.data) {
     ESP_LOGVV(TAG, "0x%02x", byte);
   }
 
-  const auto& data = service_data.data;
+  const auto &data = service_data.data;
 
   // Counter for deduplicating messages.
   uint8_t counter = data[1] & 0x0f;

esphome/components/ballu/ballu.cpp

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

esphome/components/ballu/ballu.h

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

esphome/components/ballu/climate.py

@@ -0,0 +1,21 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import climate_ir
+from esphome.const import CONF_ID
+
+AUTO_LOAD = ["climate_ir"]
+CODEOWNERS = ["@bazuchan"]
+
+ballu_ns = cg.esphome_ns.namespace("ballu")
+BalluClimate = ballu_ns.class_("BalluClimate", climate_ir.ClimateIR)
+
+CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(BalluClimate),
+    }
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await climate_ir.register_climate_ir(var, config)

esphome/components/bang_bang/bang_bang_climate.cpp

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

esphome/components/bh1750/bh1750.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace bh1750 {
 
-static const char *TAG = "bh1750.sensor";
+static const char *const TAG = "bh1750.sensor";
 
 static const uint8_t BH1750_COMMAND_POWER_ON = 0b00000001;
 static const uint8_t BH1750_COMMAND_MT_REG_HI = 0b01000000;  // last 3 bits

esphome/components/binary/fan/binary_fan.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace binary {
 
-static const char *TAG = "binary.fan";
+static const char *const TAG = "binary.fan";
 
 void binary::BinaryFan::dump_config() {
   ESP_LOGCONFIG(TAG, "Fan '%s':", this->fan_->get_name().c_str());

esphome/components/binary_sensor/__init__.py

@@ -22,7 +22,6 @@ from esphome.const import (
     CONF_STATE,
     CONF_TIMING,
     CONF_TRIGGER_ID,
-    CONF_FOR,
     CONF_NAME,
     CONF_MQTT_ID,
     DEVICE_CLASS_EMPTY,
@@ -372,11 +371,6 @@ BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend(
                 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."
-        ),
     }
 )
 
@@ -455,10 +449,6 @@ async def new_binary_sensor(config):
 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."
-        ),
     }
 )
 

esphome/components/binary_sensor/automation.cpp

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

esphome/components/binary_sensor/automation.h

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

esphome/components/binary_sensor/binary_sensor.cpp

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

esphome/components/binary_sensor/binary_sensor.h

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

esphome/components/binary_sensor/filter.cpp

@@ -1,11 +1,13 @@
 #include "filter.h"
+
 #include "binary_sensor.h"
+#include <utility>
 
 namespace esphome {
 
 namespace binary_sensor {
 
-static const char *TAG = "sensor.filter";
+static const char *const TAG = "sensor.filter";
 
 void Filter::output(bool value, bool is_initial) {
   if (!this->dedup_.next(value))
@@ -64,7 +66,7 @@ float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARD
 
 optional<bool> InvertFilter::new_value(bool value, bool is_initial) { return !value; }
 
-AutorepeatFilter::AutorepeatFilter(const std::vector<AutorepeatFilterTiming> &timings) : timings_(timings) {}
+AutorepeatFilter::AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings) : timings_(std::move(timings)) {}
 
 optional<bool> AutorepeatFilter::new_value(bool value, bool is_initial) {
   if (value) {
@@ -108,7 +110,7 @@ void AutorepeatFilter::next_value_(bool val) {
 
 float AutorepeatFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-LambdaFilter::LambdaFilter(const std::function<optional<bool>(bool)> &f) : f_(f) {}
+LambdaFilter::LambdaFilter(std::function<optional<bool>(bool)> f) : f_(std::move(f)) {}
 
 optional<bool> LambdaFilter::new_value(bool value, bool is_initial) { return this->f_(value); }
 

esphome/components/binary_sensor/filter.h

@@ -79,7 +79,7 @@ struct AutorepeatFilterTiming {
 
 class AutorepeatFilter : public Filter, public Component {
  public:
-  explicit AutorepeatFilter(const std::vector<AutorepeatFilterTiming> &timings);
+  explicit AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings);
 
   optional<bool> new_value(bool value, bool is_initial) override;
 
@@ -95,7 +95,7 @@ class AutorepeatFilter : public Filter, public Component {
 
 class LambdaFilter : public Filter {
  public:
-  explicit LambdaFilter(const std::function<optional<bool>(bool)> &f);
+  explicit LambdaFilter(std::function<optional<bool>(bool)> f);
 
   optional<bool> new_value(bool value, bool is_initial) override;
 

esphome/components/binary_sensor_map/binary_sensor_map.cpp

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

esphome/components/ble_client/ble_client.cpp

@@ -9,7 +9,7 @@
 namespace esphome {
 namespace ble_client {
 
-static const char *TAG = "ble_client";
+static const char *const TAG = "ble_client";
 
 void BLEClient::setup() {
   auto ret = esp_ble_gattc_app_register(this->app_id);

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -9,7 +9,7 @@
 namespace esphome {
 namespace ble_client {
 
-static const char *TAG = "ble_sensor";
+static const char *const TAG = "ble_sensor";
 
 uint32_t BLESensor::hash_base() { return 343459825UL; }
 

esphome/components/ble_client/switch/ble_switch.cpp

@@ -7,7 +7,7 @@
 namespace esphome {
 namespace ble_client {
 
-static const char *TAG = "ble_switch";
+static const char *const TAG = "ble_switch";
 
 void BLEClientSwitch::write_state(bool state) {
   this->parent_->set_enabled(state);

esphome/components/ble_presence/ble_presence_device.cpp

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

esphome/components/ble_rssi/ble_rssi_sensor.cpp

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

esphome/components/ble_scanner/ble_scanner.cpp

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

esphome/components/bme280/bme280.cpp

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

esphome/components/bme680/bme680.cpp

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

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace bme680_bsec {
 #ifdef USE_BSEC
-static const char *TAG = "bme680_bsec.sensor";
+static const char *const TAG = "bme680_bsec.sensor";
 
 static const std::string IAQ_ACCURACY_STATES[4] = {"Stabilizing", "Uncertain", "Calibrating", "Calibrated"};
 

esphome/components/bmp085/bmp085.cpp

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

esphome/components/bmp280/bmp280.cpp

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

esphome/components/canbus/canbus.cpp

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

esphome/components/captive_portal/captive_portal.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace captive_portal {
 
-static const char *TAG = "captive_portal";
+static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_index(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream("text/html");
@@ -147,7 +147,7 @@ float CaptivePortal::get_setup_priority() const {
 }
 void CaptivePortal::dump_config() { ESP_LOGCONFIG(TAG, "Captive Portal:"); }
 
-CaptivePortal *global_captive_portal = nullptr;
+CaptivePortal *global_captive_portal = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace captive_portal
 }  // namespace esphome

esphome/components/captive_portal/captive_portal.h

@@ -68,7 +68,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   DNSServer *dns_server_{nullptr};
 };
 
-extern CaptivePortal *global_captive_portal;
+extern CaptivePortal *global_captive_portal;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace captive_portal
 }  // namespace esphome

esphome/components/ccs811/ccs811.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace ccs811 {
 
-static const char *TAG = "ccs811";
+static const char *const TAG = "ccs811";
 
 // based on
 //  - https://cdn.sparkfun.com/datasheets/BreakoutBoards/CCS811_Programming_Guide.pdf

esphome/components/ccs811/sensor.py

@@ -8,6 +8,8 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     UNIT_PARTS_PER_MILLION,
     UNIT_PARTS_PER_BILLION,
+    CONF_BASELINE,
+    CONF_ECO2,
     CONF_TEMPERATURE,
     CONF_TVOC,
     CONF_HUMIDITY,
@@ -21,9 +23,6 @@ CCS811Component = ccs811_ns.class_(
     "CCS811Component", cg.PollingComponent, i2c.I2CDevice
 )
 
-CONF_ECO2 = "eco2"
-CONF_BASELINE = "baseline"
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {

esphome/components/climate/automation.h

@@ -27,7 +27,9 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
     call.set_target_temperature(this->target_temperature_.optional_value(x...));
     call.set_target_temperature_low(this->target_temperature_low_.optional_value(x...));
     call.set_target_temperature_high(this->target_temperature_high_.optional_value(x...));
-    call.set_away(this->away_.optional_value(x...));
+    if (away_.has_value()) {
+      call.set_preset(away_.value(x...) ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME);
+    }
     call.set_fan_mode(this->fan_mode_.optional_value(x...));
     call.set_fan_mode(this->custom_fan_mode_.optional_value(x...));
     call.set_preset(this->preset_.optional_value(x...));

esphome/components/climate/climate.cpp

@@ -3,7 +3,7 @@
 namespace esphome {
 namespace climate {
 
-static const char *TAG = "climate";
+static const char *const TAG = "climate";
 
 void ClimateCall::perform() {
   ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
@@ -43,9 +43,6 @@ void ClimateCall::perform() {
   if (this->target_temperature_high_.has_value()) {
     ESP_LOGD(TAG, "  Target Temperature High: %.2f", *this->target_temperature_high_);
   }
-  if (this->away_.has_value()) {
-    ESP_LOGD(TAG, "  Away Mode: %s", ONOFF(*this->away_));
-  }
   this->parent_->control(*this);
 }
 void ClimateCall::validate_() {
@@ -125,12 +122,6 @@ void ClimateCall::validate_() {
       this->target_temperature_high_.reset();
     }
   }
-  if (this->away_.has_value()) {
-    if (!traits.get_supports_away()) {
-      ESP_LOGW(TAG, "  Cannot set away mode for this device!");
-      this->away_.reset();
-    }
-  }
 }
 ClimateCall &ClimateCall::set_mode(ClimateMode mode) {
   this->mode_ = mode;
@@ -181,8 +172,7 @@ ClimateCall &ClimateCall::set_fan_mode(const std::string &fan_mode) {
   } else if (str_equals_case_insensitive(fan_mode, "DIFFUSE")) {
     this->set_fan_mode(CLIMATE_FAN_DIFFUSE);
   } else {
-    auto custom_fan_modes = this->parent_->get_traits().get_supported_custom_fan_modes();
-    if (std::find(custom_fan_modes.begin(), custom_fan_modes.end(), fan_mode) != custom_fan_modes.end()) {
+    if (this->parent_->get_traits().supports_custom_fan_mode(fan_mode)) {
       this->custom_fan_mode_ = fan_mode;
       this->fan_mode_.reset();
     } else {
@@ -218,8 +208,7 @@ ClimateCall &ClimateCall::set_preset(const std::string &preset) {
   } else if (str_equals_case_insensitive(preset, "ACTIVITY")) {
     this->set_preset(CLIMATE_PRESET_ACTIVITY);
   } else {
-    auto custom_presets = this->parent_->get_traits().get_supported_custom_presets();
-    if (std::find(custom_presets.begin(), custom_presets.end(), preset) != custom_presets.end()) {
+    if (this->parent_->get_traits().supports_custom_preset(preset)) {
       this->custom_preset_ = preset;
       this->preset_.reset();
     } else {
@@ -269,18 +258,23 @@ const optional<ClimateMode> &ClimateCall::get_mode() const { return this->mode_;
 const optional<float> &ClimateCall::get_target_temperature() const { return this->target_temperature_; }
 const optional<float> &ClimateCall::get_target_temperature_low() const { return this->target_temperature_low_; }
 const optional<float> &ClimateCall::get_target_temperature_high() const { return this->target_temperature_high_; }
-const optional<bool> &ClimateCall::get_away() const { return this->away_; }
+optional<bool> ClimateCall::get_away() const {
+  if (!this->preset_.has_value())
+    return {};
+  return *this->preset_ == ClimatePreset::CLIMATE_PRESET_AWAY;
+}
 const optional<ClimateFanMode> &ClimateCall::get_fan_mode() const { return this->fan_mode_; }
 const optional<std::string> &ClimateCall::get_custom_fan_mode() const { return this->custom_fan_mode_; }
 const optional<ClimatePreset> &ClimateCall::get_preset() const { return this->preset_; }
 const optional<std::string> &ClimateCall::get_custom_preset() const { return this->custom_preset_; }
 const optional<ClimateSwingMode> &ClimateCall::get_swing_mode() const { return this->swing_mode_; }
 ClimateCall &ClimateCall::set_away(bool away) {
-  this->away_ = away;
+  this->preset_ = away ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME;
   return *this;
 }
 ClimateCall &ClimateCall::set_away(optional<bool> away) {
-  this->away_ = away;
+  if (away.has_value())
+    this->preset_ = *away ? CLIMATE_PRESET_AWAY : CLIMATE_PRESET_HOME;
   return *this;
 }
 ClimateCall &ClimateCall::set_target_temperature_high(optional<float> target_temperature_high) {
@@ -338,20 +332,17 @@ void Climate::save_state_() {
   } else {
     state.target_temperature = this->target_temperature;
   }
-  if (traits.get_supports_away()) {
-    state.away = this->away;
-  }
   if (traits.get_supports_fan_modes() && fan_mode.has_value()) {
     state.uses_custom_fan_mode = false;
     state.fan_mode = this->fan_mode.value();
   }
   if (!traits.get_supported_custom_fan_modes().empty() && custom_fan_mode.has_value()) {
     state.uses_custom_fan_mode = true;
-    auto &custom_fan_modes = traits.get_supported_custom_fan_modes();
-    auto it = std::find(custom_fan_modes.begin(), custom_fan_modes.end(), this->custom_fan_mode.value());
-    // only set custom fan mode if value exists, otherwise leave it as is
-    if (it != custom_fan_modes.cend()) {
-      state.custom_fan_mode = std::distance(custom_fan_modes.begin(), it);
+    const auto &supported = traits.get_supported_custom_fan_modes();
+    std::vector<std::string> vec{supported.begin(), supported.end()};
+    auto it = std::find(vec.begin(), vec.end(), custom_fan_mode);
+    if (it != vec.end()) {
+      state.custom_fan_mode = std::distance(vec.begin(), it);
     }
   }
   if (traits.get_supports_presets() && preset.has_value()) {
@@ -360,11 +351,12 @@ void Climate::save_state_() {
   }
   if (!traits.get_supported_custom_presets().empty() && custom_preset.has_value()) {
     state.uses_custom_preset = true;
-    auto custom_presets = traits.get_supported_custom_presets();
-    auto it = std::find(custom_presets.begin(), custom_presets.end(), this->custom_preset.value());
+    const auto &supported = traits.get_supported_custom_presets();
+    std::vector<std::string> vec{supported.begin(), supported.end()};
+    auto it = std::find(vec.begin(), vec.end(), custom_preset);
     // only set custom preset if value exists, otherwise leave it as is
-    if (it != custom_presets.cend()) {
-      state.custom_preset = std::distance(custom_presets.begin(), it);
+    if (it != vec.cend()) {
+      state.custom_preset = std::distance(vec.begin(), it);
     }
   }
   if (traits.get_supports_swing_modes()) {
@@ -405,9 +397,6 @@ void Climate::publish_state() {
   } else {
     ESP_LOGD(TAG, "  Target Temperature: %.2f°C", this->target_temperature);
   }
-  if (traits.get_supports_away()) {
-    ESP_LOGD(TAG, "  Away: %s", ONOFF(this->away));
-  }
 
   // Send state to frontend
   this->state_callback_.call();
@@ -453,9 +442,6 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
   } else {
     call.set_target_temperature(this->target_temperature);
   }
-  if (traits.get_supports_away()) {
-    call.set_away(this->away);
-  }
   if (traits.get_supports_fan_modes() || !traits.get_supported_custom_fan_modes().empty()) {
     call.set_fan_mode(this->fan_mode);
   }
@@ -476,23 +462,27 @@ void ClimateDeviceRestoreState::apply(Climate *climate) {
   } else {
     climate->target_temperature = this->target_temperature;
   }
-  if (traits.get_supports_away()) {
-    climate->away = this->away;
-  }
   if (traits.get_supports_fan_modes() && !this->uses_custom_fan_mode) {
     climate->fan_mode = this->fan_mode;
   }
   if (!traits.get_supported_custom_fan_modes().empty() && this->uses_custom_fan_mode) {
-    climate->custom_fan_mode = traits.get_supported_custom_fan_modes()[this->custom_fan_mode];
+    // std::set has consistent order (lexicographic for strings), so this is ok
+    const auto &modes = traits.get_supported_custom_fan_modes();
+    std::vector<std::string> modes_vec{modes.begin(), modes.end()};
+    if (custom_fan_mode < modes_vec.size()) {
+      climate->custom_fan_mode = modes_vec[this->custom_fan_mode];
+    }
   }
   if (traits.get_supports_presets() && !this->uses_custom_preset) {
     climate->preset = this->preset;
   }
-  if (!traits.get_supported_custom_presets().empty() && this->uses_custom_preset) {
-    climate->custom_preset = traits.get_supported_custom_presets()[this->custom_preset];
-  }
   if (!traits.get_supported_custom_presets().empty() && uses_custom_preset) {
-    climate->custom_preset = traits.get_supported_custom_presets()[this->preset];
+    // std::set has consistent order (lexicographic for strings), so this is ok
+    const auto &presets = traits.get_supported_custom_presets();
+    std::vector<std::string> presets_vec{presets.begin(), presets.end()};
+    if (custom_preset < presets_vec.size()) {
+      climate->custom_preset = presets_vec[this->custom_preset];
+    }
   }
   if (traits.get_supports_swing_modes()) {
     climate->swing_mode = this->swing_mode;

esphome/components/climate/climate.h

@@ -11,8 +11,8 @@ namespace esphome {
 namespace climate {
 
 #define LOG_CLIMATE(prefix, type, obj) \
-  if (obj != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, obj->get_name().c_str()); \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
   }
 
 class Climate;
@@ -63,7 +63,9 @@ class ClimateCall {
    * For climate devices with two point target temperature control
    */
   ClimateCall &set_target_temperature_high(optional<float> target_temperature_high);
+  ESPDEPRECATED("set_away() is deprecated, please use .set_preset(CLIMATE_PRESET_AWAY) instead")
   ClimateCall &set_away(bool away);
+  ESPDEPRECATED("set_away() is deprecated, please use .set_preset(CLIMATE_PRESET_AWAY) instead")
   ClimateCall &set_away(optional<bool> away);
   /// Set the fan mode of the climate device.
   ClimateCall &set_fan_mode(ClimateFanMode fan_mode);
@@ -94,7 +96,8 @@ class ClimateCall {
   const optional<float> &get_target_temperature() const;
   const optional<float> &get_target_temperature_low() const;
   const optional<float> &get_target_temperature_high() const;
-  const optional<bool> &get_away() const;
+  ESPDEPRECATED("get_away() is deprecated, please use .get_preset() instead")
+  optional<bool> get_away() const;
   const optional<ClimateFanMode> &get_fan_mode() const;
   const optional<ClimateSwingMode> &get_swing_mode() const;
   const optional<std::string> &get_custom_fan_mode() const;
@@ -109,7 +112,6 @@ class ClimateCall {
   optional<float> target_temperature_;
   optional<float> target_temperature_low_;
   optional<float> target_temperature_high_;
-  optional<bool> away_;
   optional<ClimateFanMode> fan_mode_;
   optional<ClimateSwingMode> swing_mode_;
   optional<std::string> custom_fan_mode_;
@@ -120,7 +122,6 @@ class ClimateCall {
 /// Struct used to save the state of the climate device in restore memory.
 struct ClimateDeviceRestoreState {
   ClimateMode mode;
-  bool away;
   bool uses_custom_fan_mode{false};
   union {
     ClimateFanMode fan_mode;
@@ -191,6 +192,7 @@ class Climate : public Nameable {
    * Away allows climate devices to have two different target temperature configs:
    * one for normal mode and one for away mode.
    */
+  ESPDEPRECATED("away is deprecated, use preset instead")
   bool away{false};
 
   /// The active fan mode of the climate device.

esphome/components/climate/climate_mode.cpp

@@ -84,6 +84,10 @@ const char *climate_swing_mode_to_string(ClimateSwingMode swing_mode) {
 
 const char *climate_preset_to_string(ClimatePreset preset) {
   switch (preset) {
+    case climate::CLIMATE_PRESET_NONE:
+      return "NONE";
+    case climate::CLIMATE_PRESET_HOME:
+      return "HOME";
     case climate::CLIMATE_PRESET_ECO:
       return "ECO";
     case climate::CLIMATE_PRESET_AWAY:
@@ -92,8 +96,6 @@ const char *climate_preset_to_string(ClimatePreset preset) {
       return "BOOST";
     case climate::CLIMATE_PRESET_COMFORT:
       return "COMFORT";
-    case climate::CLIMATE_PRESET_HOME:
-      return "HOME";
     case climate::CLIMATE_PRESET_SLEEP:
       return "SLEEP";
     case climate::CLIMATE_PRESET_ACTIVITY:

esphome/components/climate/climate_mode.h

@@ -7,19 +7,22 @@ namespace climate {
 
 /// Enum for all modes a climate device can be in.
 enum ClimateMode : uint8_t {
-  /// The climate device is off (not in auto, heat or cool mode)
+  /// The climate device is off
   CLIMATE_MODE_OFF = 0,
-  /// The climate device is set to automatically change the heating/cooling cycle
+  /// The climate device is set to heat/cool to reach the target temperature.
   CLIMATE_MODE_HEAT_COOL = 1,
-  /// The climate device is manually set to cool mode (not in auto mode!)
+  /// The climate device is set to cool to reach the target temperature
   CLIMATE_MODE_COOL = 2,
-  /// The climate device is manually set to heat mode (not in auto mode!)
+  /// The climate device is set to heat to reach the target temperature
   CLIMATE_MODE_HEAT = 3,
-  /// The climate device is manually set to fan only mode
+  /// The climate device only has the fan enabled, no heating or cooling is taking place
   CLIMATE_MODE_FAN_ONLY = 4,
-  /// The climate device is manually set to dry mode
+  /// The climate device is set to dry/humidity mode
   CLIMATE_MODE_DRY = 5,
-  /// The climate device is manually set to heat-cool mode
+  /** The climate device is adjusting the temperatre dynamically.
+   * For example, the target temperature can be adjusted based on a schedule, or learned behavior.
+   * The target temperature can't be adjusted when in this mode.
+   */
   CLIMATE_MODE_AUTO = 6
 };
 
@@ -27,19 +30,18 @@ enum ClimateMode : uint8_t {
 enum ClimateAction : uint8_t {
   /// The climate device is off (inactive or no power)
   CLIMATE_ACTION_OFF = 0,
-  /// The climate device is actively cooling (usually in cool or auto mode)
+  /// The climate device is actively cooling
   CLIMATE_ACTION_COOLING = 2,
-  /// The climate device is actively heating (usually in heat or auto mode)
+  /// The climate device is actively heating
   CLIMATE_ACTION_HEATING = 3,
   /// The climate device is idle (monitoring climate but no action needed)
   CLIMATE_ACTION_IDLE = 4,
-  /// The climate device is drying (either mode DRY or AUTO)
+  /// The climate device is drying
   CLIMATE_ACTION_DRYING = 5,
-  /// The climate device is in fan only mode (either mode FAN_ONLY or AUTO)
+  /// The climate device is in fan only mode
   CLIMATE_ACTION_FAN = 6,
 };
 
-/// Enum for all modes a climate fan can be in
 enum ClimateFanMode : uint8_t {
   /// The fan mode is set to On
   CLIMATE_FAN_ON = 0,
@@ -75,20 +77,22 @@ enum ClimateSwingMode : uint8_t {
 
 /// Enum for all modes a climate swing can be in
 enum ClimatePreset : uint8_t {
-  /// Preset is set to ECO
-  CLIMATE_PRESET_ECO = 0,
-  /// Preset is set to AWAY
-  CLIMATE_PRESET_AWAY = 1,
-  /// Preset is set to BOOST
-  CLIMATE_PRESET_BOOST = 2,
-  /// Preset is set to COMFORT
-  CLIMATE_PRESET_COMFORT = 3,
-  /// Preset is set to HOME
-  CLIMATE_PRESET_HOME = 4,
-  /// Preset is set to SLEEP
-  CLIMATE_PRESET_SLEEP = 5,
-  /// Preset is set to ACTIVITY
-  CLIMATE_PRESET_ACTIVITY = 6,
+  /// No preset is active
+  CLIMATE_PRESET_NONE = 0,
+  /// Device is in home preset
+  CLIMATE_PRESET_HOME = 1,
+  /// Device is in away preset
+  CLIMATE_PRESET_AWAY = 2,
+  /// Device is in boost preset
+  CLIMATE_PRESET_BOOST = 3,
+  /// Device is in comfort preset
+  CLIMATE_PRESET_COMFORT = 4,
+  /// Device is running an energy-saving preset
+  CLIMATE_PRESET_ECO = 5,
+  /// Device is prepared for sleep
+  CLIMATE_PRESET_SLEEP = 6,
+  /// Device is reacting to activity (e.g., movement sensors)
+  CLIMATE_PRESET_ACTIVITY = 7,
 };
 
 /// Convert the given ClimateMode to a human-readable string.

esphome/components/climate/climate_traits.cpp

@@ -4,55 +4,6 @@
 namespace esphome {
 namespace climate {
 
-bool ClimateTraits::supports_mode(ClimateMode mode) const {
-  switch (mode) {
-    case CLIMATE_MODE_OFF:
-      return true;
-    case CLIMATE_MODE_HEAT_COOL:
-      return this->supports_heat_cool_mode_;
-    case CLIMATE_MODE_AUTO:
-      return this->supports_auto_mode_;
-    case CLIMATE_MODE_COOL:
-      return this->supports_cool_mode_;
-    case CLIMATE_MODE_HEAT:
-      return this->supports_heat_mode_;
-    case CLIMATE_MODE_FAN_ONLY:
-      return this->supports_fan_only_mode_;
-    case CLIMATE_MODE_DRY:
-      return this->supports_dry_mode_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_current_temperature() const { return supports_current_temperature_; }
-void ClimateTraits::set_supports_current_temperature(bool supports_current_temperature) {
-  supports_current_temperature_ = supports_current_temperature;
-}
-bool ClimateTraits::get_supports_two_point_target_temperature() const { return supports_two_point_target_temperature_; }
-void ClimateTraits::set_supports_two_point_target_temperature(bool supports_two_point_target_temperature) {
-  supports_two_point_target_temperature_ = supports_two_point_target_temperature;
-}
-void ClimateTraits::set_supports_auto_mode(bool supports_auto_mode) { supports_auto_mode_ = supports_auto_mode; }
-void ClimateTraits::set_supports_heat_cool_mode(bool supports_heat_cool_mode) {
-  supports_heat_cool_mode_ = supports_heat_cool_mode;
-}
-void ClimateTraits::set_supports_cool_mode(bool supports_cool_mode) { supports_cool_mode_ = supports_cool_mode; }
-void ClimateTraits::set_supports_heat_mode(bool supports_heat_mode) { supports_heat_mode_ = supports_heat_mode; }
-void ClimateTraits::set_supports_fan_only_mode(bool supports_fan_only_mode) {
-  supports_fan_only_mode_ = supports_fan_only_mode;
-}
-void ClimateTraits::set_supports_dry_mode(bool supports_dry_mode) { supports_dry_mode_ = supports_dry_mode; }
-void ClimateTraits::set_supports_away(bool supports_away) { supports_away_ = supports_away; }
-void ClimateTraits::set_supports_action(bool supports_action) { supports_action_ = supports_action; }
-float ClimateTraits::get_visual_min_temperature() const { return visual_min_temperature_; }
-void ClimateTraits::set_visual_min_temperature(float visual_min_temperature) {
-  visual_min_temperature_ = visual_min_temperature;
-}
-float ClimateTraits::get_visual_max_temperature() const { return visual_max_temperature_; }
-void ClimateTraits::set_visual_max_temperature(float visual_max_temperature) {
-  visual_max_temperature_ = visual_max_temperature;
-}
-float ClimateTraits::get_visual_temperature_step() const { return visual_temperature_step_; }
 int8_t ClimateTraits::get_temperature_accuracy_decimals() const {
   // use printf %g to find number of digits based on temperature step
   char buf[32];
@@ -64,160 +15,6 @@ int8_t ClimateTraits::get_temperature_accuracy_decimals() const {
 
   return str.length() - dot_pos - 1;
 }
-void ClimateTraits::set_visual_temperature_step(float temperature_step) { visual_temperature_step_ = temperature_step; }
-bool ClimateTraits::get_supports_away() const { return supports_away_; }
-bool ClimateTraits::get_supports_action() const { return supports_action_; }
 
-void ClimateTraits::set_supports_fan_mode_on(bool supports_fan_mode_on) {
-  this->supports_fan_mode_on_ = supports_fan_mode_on;
-}
-void ClimateTraits::set_supports_fan_mode_off(bool supports_fan_mode_off) {
-  this->supports_fan_mode_off_ = supports_fan_mode_off;
-}
-void ClimateTraits::set_supports_fan_mode_auto(bool supports_fan_mode_auto) {
-  this->supports_fan_mode_auto_ = supports_fan_mode_auto;
-}
-void ClimateTraits::set_supports_fan_mode_low(bool supports_fan_mode_low) {
-  this->supports_fan_mode_low_ = supports_fan_mode_low;
-}
-void ClimateTraits::set_supports_fan_mode_medium(bool supports_fan_mode_medium) {
-  this->supports_fan_mode_medium_ = supports_fan_mode_medium;
-}
-void ClimateTraits::set_supports_fan_mode_high(bool supports_fan_mode_high) {
-  this->supports_fan_mode_high_ = supports_fan_mode_high;
-}
-void ClimateTraits::set_supports_fan_mode_middle(bool supports_fan_mode_middle) {
-  this->supports_fan_mode_middle_ = supports_fan_mode_middle;
-}
-void ClimateTraits::set_supports_fan_mode_focus(bool supports_fan_mode_focus) {
-  this->supports_fan_mode_focus_ = supports_fan_mode_focus;
-}
-void ClimateTraits::set_supports_fan_mode_diffuse(bool supports_fan_mode_diffuse) {
-  this->supports_fan_mode_diffuse_ = supports_fan_mode_diffuse;
-}
-bool ClimateTraits::supports_fan_mode(ClimateFanMode fan_mode) const {
-  switch (fan_mode) {
-    case climate::CLIMATE_FAN_ON:
-      return this->supports_fan_mode_on_;
-    case climate::CLIMATE_FAN_OFF:
-      return this->supports_fan_mode_off_;
-    case climate::CLIMATE_FAN_AUTO:
-      return this->supports_fan_mode_auto_;
-    case climate::CLIMATE_FAN_LOW:
-      return this->supports_fan_mode_low_;
-    case climate::CLIMATE_FAN_MEDIUM:
-      return this->supports_fan_mode_medium_;
-    case climate::CLIMATE_FAN_HIGH:
-      return this->supports_fan_mode_high_;
-    case climate::CLIMATE_FAN_MIDDLE:
-      return this->supports_fan_mode_middle_;
-    case climate::CLIMATE_FAN_FOCUS:
-      return this->supports_fan_mode_focus_;
-    case climate::CLIMATE_FAN_DIFFUSE:
-      return this->supports_fan_mode_diffuse_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_fan_modes() const {
-  return this->supports_fan_mode_on_ || this->supports_fan_mode_off_ || this->supports_fan_mode_auto_ ||
-         this->supports_fan_mode_low_ || this->supports_fan_mode_medium_ || this->supports_fan_mode_high_ ||
-         this->supports_fan_mode_middle_ || this->supports_fan_mode_focus_ || this->supports_fan_mode_diffuse_;
-}
-void ClimateTraits::set_supported_custom_fan_modes(std::vector<std::string> &supported_custom_fan_modes) {
-  this->supported_custom_fan_modes_ = supported_custom_fan_modes;
-}
-const std::vector<std::string> ClimateTraits::get_supported_custom_fan_modes() const {
-  return this->supported_custom_fan_modes_;
-}
-bool ClimateTraits::supports_custom_fan_mode(std::string &custom_fan_mode) const {
-  return std::count(this->supported_custom_fan_modes_.begin(), this->supported_custom_fan_modes_.end(),
-                    custom_fan_mode);
-}
-bool ClimateTraits::supports_preset(ClimatePreset preset) const {
-  switch (preset) {
-    case climate::CLIMATE_PRESET_ECO:
-      return this->supports_preset_eco_;
-    case climate::CLIMATE_PRESET_AWAY:
-      return this->supports_preset_away_;
-    case climate::CLIMATE_PRESET_BOOST:
-      return this->supports_preset_boost_;
-    case climate::CLIMATE_PRESET_COMFORT:
-      return this->supports_preset_comfort_;
-    case climate::CLIMATE_PRESET_HOME:
-      return this->supports_preset_home_;
-    case climate::CLIMATE_PRESET_SLEEP:
-      return this->supports_preset_sleep_;
-    case climate::CLIMATE_PRESET_ACTIVITY:
-      return this->supports_preset_activity_;
-    default:
-      return false;
-  }
-}
-void ClimateTraits::set_supports_preset_eco(bool supports_preset_eco) {
-  this->supports_preset_eco_ = supports_preset_eco;
-}
-void ClimateTraits::set_supports_preset_away(bool supports_preset_away) {
-  this->supports_preset_away_ = supports_preset_away;
-}
-void ClimateTraits::set_supports_preset_boost(bool supports_preset_boost) {
-  this->supports_preset_boost_ = supports_preset_boost;
-}
-void ClimateTraits::set_supports_preset_comfort(bool supports_preset_comfort) {
-  this->supports_preset_comfort_ = supports_preset_comfort;
-}
-void ClimateTraits::set_supports_preset_home(bool supports_preset_home) {
-  this->supports_preset_home_ = supports_preset_home;
-}
-void ClimateTraits::set_supports_preset_sleep(bool supports_preset_sleep) {
-  this->supports_preset_sleep_ = supports_preset_sleep;
-}
-void ClimateTraits::set_supports_preset_activity(bool supports_preset_activity) {
-  this->supports_preset_activity_ = supports_preset_activity;
-}
-bool ClimateTraits::get_supports_presets() const {
-  return this->supports_preset_eco_ || this->supports_preset_away_ || this->supports_preset_boost_ ||
-         this->supports_preset_comfort_ || this->supports_preset_home_ || this->supports_preset_sleep_ ||
-         this->supports_preset_activity_;
-}
-void ClimateTraits::set_supported_custom_presets(std::vector<std::string> &supported_custom_presets) {
-  this->supported_custom_presets_ = supported_custom_presets;
-}
-const std::vector<std::string> ClimateTraits::get_supported_custom_presets() const {
-  return this->supported_custom_presets_;
-}
-bool ClimateTraits::supports_custom_preset(std::string &custom_preset) const {
-  return std::count(this->supported_custom_presets_.begin(), this->supported_custom_presets_.end(), custom_preset);
-}
-void ClimateTraits::set_supports_swing_mode_off(bool supports_swing_mode_off) {
-  this->supports_swing_mode_off_ = supports_swing_mode_off;
-}
-void ClimateTraits::set_supports_swing_mode_both(bool supports_swing_mode_both) {
-  this->supports_swing_mode_both_ = supports_swing_mode_both;
-}
-void ClimateTraits::set_supports_swing_mode_vertical(bool supports_swing_mode_vertical) {
-  this->supports_swing_mode_vertical_ = supports_swing_mode_vertical;
-}
-void ClimateTraits::set_supports_swing_mode_horizontal(bool supports_swing_mode_horizontal) {
-  this->supports_swing_mode_horizontal_ = supports_swing_mode_horizontal;
-}
-bool ClimateTraits::supports_swing_mode(ClimateSwingMode swing_mode) const {
-  switch (swing_mode) {
-    case climate::CLIMATE_SWING_OFF:
-      return this->supports_swing_mode_off_;
-    case climate::CLIMATE_SWING_BOTH:
-      return this->supports_swing_mode_both_;
-    case climate::CLIMATE_SWING_VERTICAL:
-      return this->supports_swing_mode_vertical_;
-    case climate::CLIMATE_SWING_HORIZONTAL:
-      return this->supports_swing_mode_horizontal_;
-    default:
-      return false;
-  }
-}
-bool ClimateTraits::get_supports_swing_modes() const {
-  return this->supports_swing_mode_off_ || this->supports_swing_mode_both_ || supports_swing_mode_vertical_ ||
-         supports_swing_mode_horizontal_;
-}
 }  // namespace climate
 }  // namespace esphome

esphome/components/climate/climate_traits.h

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

esphome/components/climate_ir/climate_ir.cpp

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

esphome/components/climate_ir/climate_ir.h

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

esphome/components/climate_ir_lg/climate_ir_lg.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace climate_ir_lg {
 
-static const char *TAG = "climate.climate_ir_lg";
+static const char *const TAG = "climate.climate_ir_lg";
 
 const uint32_t COMMAND_ON = 0x00000;
 const uint32_t COMMAND_ON_AI = 0x03000;
@@ -94,7 +94,7 @@ void LgIrClimate::transmit_state() {
       // remote_state |= FAN_MODE_AUTO_DRY;
     }
     if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT) {
-      auto temp = (uint8_t) roundf(clamp(this->target_temperature, TEMP_MIN, TEMP_MAX));
+      auto temp = (uint8_t) roundf(clamp<float>(this->target_temperature, TEMP_MIN, TEMP_MAX));
       remote_state |= ((temp - 15) << TEMP_SHIFT);
     }
   }

esphome/components/coolix/coolix.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace coolix {
 
-static const char *TAG = "coolix.climate";
+static const char *const TAG = "coolix.climate";
 
 const uint32_t COOLIX_OFF = 0xB27BE0;
 const uint32_t COOLIX_SWING = 0xB26BE0;
@@ -84,7 +84,7 @@ void CoolixClimate::transmit_state() {
     }
     if (this->mode != climate::CLIMATE_MODE_OFF) {
       if (this->mode != climate::CLIMATE_MODE_FAN_ONLY) {
-        auto temp = (uint8_t) roundf(clamp(this->target_temperature, COOLIX_TEMP_MIN, COOLIX_TEMP_MAX));
+        auto temp = (uint8_t) roundf(clamp<float>(this->target_temperature, COOLIX_TEMP_MIN, COOLIX_TEMP_MAX));
         remote_state |= COOLIX_TEMP_MAP[temp - COOLIX_TEMP_MIN];
       } else {
         remote_state |= COOLIX_FAN_TEMP_CODE;

esphome/components/cover/cover.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace cover {
 
-static const char *TAG = "cover";
+static const char *const TAG = "cover";
 
 const float COVER_OPEN = 1.0f;
 const float COVER_CLOSED = 0.0f;

esphome/components/cover/cover.h

@@ -12,14 +12,14 @@ const extern float COVER_OPEN;
 const extern float COVER_CLOSED;
 
 #define LOG_COVER(prefix, type, obj) \
-  if (obj != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, obj->get_name().c_str()); \
-    auto traits_ = obj->get_traits(); \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    auto traits_ = (obj)->get_traits(); \
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    if (!obj->get_device_class().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, obj->get_device_class().c_str()); \
+    if (!(obj)->get_device_class().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
   }
 
@@ -110,15 +110,12 @@ class Cover : public Nameable {
 
   /// The current operation of the cover (idle, opening, closing).
   CoverOperation current_operation{COVER_OPERATION_IDLE};
-  union {
-    /** The position of the cover from 0.0 (fully closed) to 1.0 (fully open).
-     *
-     * For binary covers this is always equals to 0.0 or 1.0 (see also COVER_OPEN and
-     * COVER_CLOSED constants).
-     */
-    float position;
-    ESPDEPRECATED("<cover>.state is deprecated, please use .position instead") float state;
-  };
+  /** The position of the cover from 0.0 (fully closed) to 1.0 (fully open).
+   *
+   * For binary covers this is always equals to 0.0 or 1.0 (see also COVER_OPEN and
+   * COVER_CLOSED constants).
+   */
+  float position;
   /// The current tilt value of the cover from 0.0 to 1.0.
   float tilt{COVER_OPEN};
 

esphome/components/cs5460a/cs5460a.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace cs5460a {
 
-static const char *TAG = "cs5460a";
+static const char *const TAG = "cs5460a";
 
 void CS5460AComponent::write_register_(enum CS5460ARegister addr, uint32_t value) {
   this->write_byte(CMD_WRITE | (addr << 1));

esphome/components/cse7766/cse7766.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace cse7766 {
 
-static const char *TAG = "cse7766";
+static const char *const TAG = "cse7766";
 
 void CSE7766Component::loop() {
   const uint32_t now = millis();

esphome/components/ct_clamp/ct_clamp_sensor.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace ct_clamp {
 
-static const char *TAG = "ct_clamp";
+static const char *const TAG = "ct_clamp";
 
 void CTClampSensor::setup() {
   this->is_calibrating_offset_ = true;

esphome/components/custom/binary_sensor/custom_binary_sensor.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace custom {
 
-static const char *TAG = "custom.binary_sensor";
+static const char *const TAG = "custom.binary_sensor";
 
 void CustomBinarySensorConstructor::dump_config() {
   for (auto *child : this->binary_sensors_) {

esphome/components/custom/output/custom_output.h

@@ -9,7 +9,9 @@ namespace custom {
 
 class CustomBinaryOutputConstructor {
  public:
-  CustomBinaryOutputConstructor(std::function<std::vector<output::BinaryOutput *>()> init) { this->outputs_ = init(); }
+  CustomBinaryOutputConstructor(const std::function<std::vector<output::BinaryOutput *>()> &init) {
+    this->outputs_ = init();
+  }
 
   output::BinaryOutput *get_output(int i) { return this->outputs_[i]; }
 
@@ -19,7 +21,9 @@ class CustomBinaryOutputConstructor {
 
 class CustomFloatOutputConstructor {
  public:
-  CustomFloatOutputConstructor(std::function<std::vector<output::FloatOutput *>()> init) { this->outputs_ = init(); }
+  CustomFloatOutputConstructor(const std::function<std::vector<output::FloatOutput *>()> &init) {
+    this->outputs_ = init();
+  }
 
   output::FloatOutput *get_output(int i) { return this->outputs_[i]; }
 

esphome/components/custom/sensor/custom_sensor.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace custom {
 
-static const char *TAG = "custom.sensor";
+static const char *const TAG = "custom.sensor";
 
 void CustomSensorConstructor::dump_config() {
   for (auto *child : this->sensors_) {

esphome/components/custom/switch/custom_switch.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace custom {
 
-static const char *TAG = "custom.switch";
+static const char *const TAG = "custom.switch";
 
 void CustomSwitchConstructor::dump_config() {
   for (auto *child : this->switches_) {

esphome/components/custom/switch/custom_switch.h

@@ -8,7 +8,7 @@ namespace custom {
 
 class CustomSwitchConstructor : public Component {
  public:
-  CustomSwitchConstructor(std::function<std::vector<switch_::Switch *>()> init) { this->switches_ = init(); }
+  CustomSwitchConstructor(const std::function<std::vector<switch_::Switch *>()> &init) { this->switches_ = init(); }
 
   switch_::Switch *get_switch(int i) { return this->switches_[i]; }
 

esphome/components/custom/text_sensor/custom_text_sensor.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace custom {
 
-static const char *TAG = "custom.text_sensor";
+static const char *const TAG = "custom.text_sensor";
 
 void CustomTextSensorConstructor::dump_config() {
   for (auto *child : this->text_sensors_) {

esphome/components/custom/text_sensor/custom_text_sensor.h

@@ -8,7 +8,7 @@ namespace custom {
 
 class CustomTextSensorConstructor : public Component {
  public:
-  CustomTextSensorConstructor(std::function<std::vector<text_sensor::TextSensor *>()> init) {
+  CustomTextSensorConstructor(const std::function<std::vector<text_sensor::TextSensor *>()> &init) {
     this->text_sensors_ = init();
   }
 

esphome/components/cwww/light.py

@@ -14,15 +14,18 @@ CWWWLightOutput = cwww_ns.class_("CWWWLightOutput", light.LightOutput)
 
 CONF_CONSTANT_BRIGHTNESS = "constant_brightness"
 
-CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend(
-    {
-        cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(CWWWLightOutput),
-        cv.Required(CONF_COLD_WHITE): cv.use_id(output.FloatOutput),
-        cv.Required(CONF_WARM_WHITE): cv.use_id(output.FloatOutput),
-        cv.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
-        cv.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
-        cv.Optional(CONF_CONSTANT_BRIGHTNESS, default=False): cv.boolean,
-    }
+CONFIG_SCHEMA = cv.All(
+    light.RGB_LIGHT_SCHEMA.extend(
+        {
+            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(CWWWLightOutput),
+            cv.Required(CONF_COLD_WHITE): cv.use_id(output.FloatOutput),
+            cv.Required(CONF_WARM_WHITE): cv.use_id(output.FloatOutput),
+            cv.Required(CONF_COLD_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
+            cv.Required(CONF_WARM_WHITE_COLOR_TEMPERATURE): cv.color_temperature,
+            cv.Optional(CONF_CONSTANT_BRIGHTNESS, default=False): cv.boolean,
+        }
+    ),
+    light.validate_color_temperature_channels,
 )
 
 

esphome/components/daikin/daikin.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace daikin {
 
-static const char *TAG = "daikin.climate";
+static const char *const TAG = "daikin.climate";
 
 void DaikinClimate::transmit_state() {
   uint8_t remote_state[35] = {0x11, 0xDA, 0x27, 0x00, 0xC5, 0x00, 0x00, 0xD7, 0x11, 0xDA, 0x27, 0x00,
@@ -135,7 +135,7 @@ uint8_t DaikinClimate::temperature_() {
     case climate::CLIMATE_MODE_DRY:
       return 0xc0;
     default:
-      uint8_t temperature = (uint8_t) roundf(clamp(this->target_temperature, DAIKIN_TEMP_MIN, DAIKIN_TEMP_MAX));
+      uint8_t temperature = (uint8_t) roundf(clamp<float>(this->target_temperature, DAIKIN_TEMP_MIN, DAIKIN_TEMP_MAX));
       return temperature << 1;
   }
 }

esphome/components/daikin/daikin.h

@@ -43,12 +43,11 @@ const uint8_t DAIKIN_STATE_FRAME_SIZE = 19;
 class DaikinClimate : public climate_ir::ClimateIR {
  public:
   DaikinClimate()
-      : climate_ir::ClimateIR(
-            DAIKIN_TEMP_MIN, DAIKIN_TEMP_MAX, 1.0f, true, true,
-            std::vector<climate::ClimateFanMode>{climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW,
-                                                 climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH},
-            std::vector<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
-                                                   climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}) {}
+      : climate_ir::ClimateIR(DAIKIN_TEMP_MIN, DAIKIN_TEMP_MAX, 1.0f, true, true,
+                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                               climate::CLIMATE_FAN_HIGH},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
+                               climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}) {}
 
  protected:
   // Transmit via IR the state of this climate controller.

esphome/components/dallas/dallas_component.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace dallas {
 
-static const char *TAG = "dallas.sensor";
+static const char *const TAG = "dallas.sensor";
 
 static const uint8_t DALLAS_MODEL_DS18S20 = 0x10;
 static const uint8_t DALLAS_MODEL_DS1822 = 0x22;

esphome/components/dallas/esp_one_wire.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace dallas {
 
-static const char *TAG = "dallas.one_wire";
+static const char *const TAG = "dallas.one_wire";
 
 const uint8_t ONE_WIRE_ROM_SELECT = 0x55;
 const int ONE_WIRE_ROM_SEARCH = 0xF0;

esphome/components/debug/debug_component.cpp

@@ -11,7 +11,7 @@
 namespace esphome {
 namespace debug {
 
-static const char *TAG = "debug";
+static const char *const TAG = "debug";
 
 void DebugComponent::dump_config() {
 #ifndef ESPHOME_LOG_HAS_DEBUG

esphome/components/deep_sleep/__init__.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_MODE,
     CONF_NUMBER,
     CONF_PINS,
-    CONF_RUN_CYCLES,
     CONF_RUN_DURATION,
     CONF_SLEEP_DURATION,
     CONF_WAKEUP_PIN,
@@ -69,11 +68,6 @@ CONFIG_SCHEMA = cv.Schema(
                 }
             ),
         ),
-        cv.Optional(CONF_RUN_CYCLES): cv.invalid(
-            "The run_cycles option has been removed in 1.11.0 as "
-            "it was essentially the same as a run_duration of 0s."
-            "Please use run_duration now."
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -5,9 +5,9 @@
 namespace esphome {
 namespace deep_sleep {
 
-static const char *TAG = "deep_sleep";
+static const char *const TAG = "deep_sleep";
 
-bool global_has_deep_sleep = false;
+bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void DeepSleepComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");

esphome/components/deep_sleep/deep_sleep_component.h

@@ -79,7 +79,7 @@ class DeepSleepComponent : public Component {
   bool prevent_{false};
 };
 
-extern bool global_has_deep_sleep;
+extern bool global_has_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 template<typename... Ts> class EnterDeepSleepAction : public Action<Ts...> {
  public:

esphome/components/dfplayer/dfplayer.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace dfplayer {
 
-static const char* TAG = "dfplayer";
+static const char *const TAG = "dfplayer";
 
 void DFPlayer::play_folder(uint16_t folder, uint16_t file) {
   if (folder < 100 && file < 256) {

esphome/components/dfplayer/dfplayer.h

@@ -103,7 +103,10 @@ class DFPlayer : public uart::UARTDevice, public Component {
 };
 
 #define DFPLAYER_SIMPLE_ACTION(ACTION_CLASS, ACTION_METHOD) \
-  template<typename... Ts> class ACTION_CLASS : public Action<Ts...>, public Parented<DFPlayer> { \
+  template<typename... Ts> \
+  class ACTION_CLASS : /* NOLINT */ \
+                       public Action<Ts...>, \
+                       public Parented<DFPlayer> { \
     void play(Ts... x) override { this->parent_->ACTION_METHOD(); } \
   };
 

esphome/components/dht/dht.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace dht {
 
-static const char *TAG = "dht";
+static const char *const TAG = "dht";
 
 void DHT::setup() {
   ESP_LOGCONFIG(TAG, "Setting up DHT...");
@@ -94,11 +94,17 @@ bool HOT ICACHE_RAM_ATTR DHT::read_sensor_(float *temperature, float *humidity,
       delayMicroseconds(40);
     } else if (this->model_ == DHT_MODEL_DHT22_TYPE2) {
       delayMicroseconds(2000);
+    } else if (this->model_ == DHT_MODEL_AM2302) {
+      delayMicroseconds(1000);
     } else {
       delayMicroseconds(800);
     }
     this->pin_->pin_mode(INPUT_PULLUP);
-    delayMicroseconds(40);
+
+    // Host pull up 20-40us then DHT response 80us
+    // Start waiting for initial rising edge at the center when we
+    // expect the DHT response (30us+40us)
+    delayMicroseconds(70);
 
     uint8_t bit = 7;
     uint8_t byte = 0;
@@ -116,8 +122,6 @@ bool HOT ICACHE_RAM_ATTR DHT::read_sensor_(float *temperature, float *humidity,
           break;
         }
       }
-      if (error_code != 0)
-        break;
 
       start_time = micros();
       uint32_t end_time = start_time;
@@ -132,8 +136,6 @@ bool HOT ICACHE_RAM_ATTR DHT::read_sensor_(float *temperature, float *humidity,
           break;
         }
       }
-      if (error_code != 0)
-        break;
 
       if (i < 0)
         continue;

esphome/components/dht12/dht12.cpp

@@ -8,7 +8,7 @@
 namespace esphome {
 namespace dht12 {
 
-static const char *TAG = "dht12";
+static const char *const TAG = "dht12";
 
 void DHT12Component::update() {
   uint8_t data[5];

esphome/components/display/display_buffer.cpp

@@ -1,12 +1,14 @@
 #include "display_buffer.h"
+
+#include "esphome/core/application.h"
 #include "esphome/core/color.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
+#include <utility>
 
 namespace esphome {
 namespace display {
 
-static const char *TAG = "display";
+static const char *const TAG = "display";
 
 const Color COLOR_OFF(0, 0, 0, 0);
 const Color COLOR_ON(255, 255, 255, 255);
@@ -524,7 +526,7 @@ void Animation::next_frame() {
   }
 }
 
-DisplayPage::DisplayPage(const display_writer_t &writer) : writer_(writer) {}
+DisplayPage::DisplayPage(display_writer_t writer) : writer_(std::move(writer)) {}
 void DisplayPage::show() { this->parent_->show_page(this); }
 void DisplayPage::show_next() { this->next_->show(); }
 void DisplayPage::show_prev() { this->prev_->show(); }

esphome/components/display/display_buffer.h

@@ -86,10 +86,10 @@ class DisplayOnPageChangeTrigger;
 using display_writer_t = std::function<void(DisplayBuffer &)>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
-  if (obj != nullptr) { \
+  if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, prefix type); \
-    ESP_LOGCONFIG(TAG, "%s  Rotations: %d °", prefix, obj->rotation_); \
-    ESP_LOGCONFIG(TAG, "%s  Dimensions: %dpx x %dpx", prefix, obj->get_width(), obj->get_height()); \
+    ESP_LOGCONFIG(TAG, "%s  Rotations: %d °", prefix, (obj)->rotation_); \
+    ESP_LOGCONFIG(TAG, "%s  Dimensions: %dpx x %dpx", prefix, (obj)->get_width(), (obj)->get_height()); \
   }
 
 class DisplayBuffer {
@@ -327,7 +327,7 @@ class DisplayBuffer {
 
 class DisplayPage {
  public:
-  DisplayPage(const display_writer_t &writer);
+  DisplayPage(display_writer_t writer);
   void show();
   void show_next();
   void show_prev();

esphome/components/ds1307/ds1307.cpp

@@ -7,7 +7,7 @@
 namespace esphome {
 namespace ds1307 {
 
-static const char *TAG = "ds1307";
+static const char *const TAG = "ds1307";
 
 void DS1307Component::setup() {
   ESP_LOGCONFIG(TAG, "Setting up DS1307...");

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace duty_cycle {
 
-static const char *TAG = "duty_cycle";
+static const char *const TAG = "duty_cycle";
 
 void DutyCycleSensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Duty Cycle Sensor '%s'...", this->get_name().c_str());

esphome/components/e131/e131.cpp

@@ -14,7 +14,7 @@
 namespace esphome {
 namespace e131 {
 
-static const char *TAG = "e131";
+static const char *const TAG = "e131";
 static const int PORT = 5568;
 
 E131Component::E131Component() {}

esphome/components/e131/e131_addressable_light_effect.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace e131 {
 
-static const char *TAG = "e131_addressable_light_effect";
+static const char *const TAG = "e131_addressable_light_effect";
 static const int MAX_DATA_SIZE = (sizeof(E131Packet::values) - 1);
 
 E131AddressableLightEffect::E131AddressableLightEffect(const std::string &name) : AddressableLightEffect(name) {}

esphome/components/e131/e131_packet.cpp

@@ -8,7 +8,7 @@
 namespace esphome {
 namespace e131 {
 
-static const char *TAG = "e131";
+static const char *const TAG = "e131";
 
 static const uint8_t ACN_ID[12] = {0x41, 0x53, 0x43, 0x2d, 0x45, 0x31, 0x2e, 0x31, 0x37, 0x00, 0x00, 0x00};
 static const uint32_t VECTOR_ROOT = 4;
@@ -51,7 +51,7 @@ union E131RawPacket {
 
 // We need to have at least one `1` value
 // Get the offset of `property_values[1]`
-const long E131_MIN_PACKET_SIZE = reinterpret_cast<long>(&((E131RawPacket *) nullptr)->property_values[1]);
+const size_t E131_MIN_PACKET_SIZE = reinterpret_cast<size_t>(&((E131RawPacket *) nullptr)->property_values[1]);
 
 bool E131Component::join_igmp_groups_() {
   if (listen_method_ != E131_MULTICAST)

esphome/components/endstop/endstop_cover.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace endstop {
 
-static const char *TAG = "endstop.cover";
+static const char *const TAG = "endstop.cover";
 
 using namespace esphome::cover;
 

esphome/components/esp32_ble/ble.cpp

@@ -15,7 +15,7 @@
 namespace esphome {
 namespace esp32_ble {
 
-static const char *TAG = "esp32_ble";
+static const char *const TAG = "esp32_ble";
 
 void ESP32BLE::setup() {
   global_ble = this;

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -13,7 +13,7 @@
 namespace esphome {
 namespace esp32_ble_beacon {
 
-static const char *TAG = "esp32_ble_beacon";
+static const char *const TAG = "esp32_ble_beacon";
 
 static esp_ble_adv_params_t ble_adv_params = {
     .adv_int_min = 0x20,

esphome/components/esp32_ble_tracker/__init__.py

@@ -163,9 +163,6 @@ CONFIG_SCHEMA = cv.Schema(
                 cv.Required(CONF_MANUFACTURER_ID): bt_uuid,
             }
         ),
-        cv.Optional("scan_interval"): cv.invalid(
-            "This option has been removed in 1.14 (Reason: " "it never had an effect)"
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/esp32_ble_tracker/binary_sensor.py

@@ -1,3 +0,0 @@
-import esphome.config_validation as cv
-
-CONFIG_SCHEMA = cv.invalid("This platform has been renamed to ble_presence in 1.13")

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -19,7 +19,7 @@
 namespace esphome {
 namespace esp32_ble_tracker {
 
-static const char *TAG = "esp32_ble_tracker";
+static const char *const TAG = "esp32_ble_tracker";
 
 ESP32BLETracker *global_esp32_ble_tracker = nullptr;
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -85,12 +85,6 @@ class ESPBTDevice {
   int get_rssi() const { return rssi_; }
   const std::string &get_name() const { return this->name_; }
 
-  ESPDEPRECATED("Use get_tx_powers() instead")
-  optional<int8_t> get_tx_power() const {
-    if (this->tx_powers_.empty())
-      return {};
-    return this->tx_powers_[0];
-  }
   const std::vector<int8_t> &get_tx_powers() const { return tx_powers_; }
 
   const optional<uint16_t> &get_appearance() const { return appearance_; }

esphome/components/esp32_camera/esp32_camera.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace esp32_camera {
 
-static const char *TAG = "esp32_camera";
+static const char *const TAG = "esp32_camera";
 
 void ESP32Camera::setup() {
   global_esp32_camera = this;

esphome/components/esp32_dac/esp32_dac.cpp

@@ -9,7 +9,7 @@
 namespace esphome {
 namespace esp32_dac {
 
-static const char *TAG = "esp32_dac";
+static const char *const TAG = "esp32_dac";
 
 void ESP32DAC::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ESP32 DAC Output...");

esphome/components/esp32_hall/esp32_hall.cpp

@@ -7,7 +7,7 @@
 namespace esphome {
 namespace esp32_hall {
 
-static const char *TAG = "esp32_hall";
+static const char *const TAG = "esp32_hall";
 
 void ESP32HallSensor::update() {
   float value = (hallRead() / 4095.0f) * 10000.0f;

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -10,7 +10,7 @@
 namespace esphome {
 namespace esp32_improv {
 
-static const char *TAG = "esp32_improv.component";
+static const char *const TAG = "esp32_improv.component";
 
 ESP32ImprovComponent::ESP32ImprovComponent() { global_improv_component = this; }
 

esphome/components/esp32_touch/esp32_touch.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace esp32_touch {
 
-static const char *TAG = "esp32_touch";
+static const char *const TAG = "esp32_touch";
 
 void ESP32TouchComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ESP32 Touch Hub...");

esphome/components/esp8266_pwm/esp8266_pwm.cpp

@@ -11,7 +11,7 @@
 namespace esphome {
 namespace esp8266_pwm {
 
-static const char *TAG = "esp8266_pwm";
+static const char *const TAG = "esp8266_pwm";
 
 void ESP8266PWM::setup() {
   ESP_LOGCONFIG(TAG, "Setting up ESP8266 PWM Output...");

esphome/components/ethernet/__init__.py

@@ -85,9 +85,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ENABLE_MDNS, default=True): cv.boolean,
             cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name,
             cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
-            cv.Optional("hostname"): cv.invalid(
-                "The hostname option has been removed in 1.11.0"
-            ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     _validate,

esphome/components/ethernet/ethernet_component.cpp

@@ -9,6 +9,11 @@
 #include <eth_phy/phy_tlk110.h>
 #include <lwip/dns.h>
 
+/// Macro for IDF version comparision
+#ifndef ESP_IDF_VERSION_VAL
+#define ESP_IDF_VERSION_VAL(major, minor, patch) (((major) << 16) | ((minor) << 8) | (patch))
+#endif
+
 // Defined in WiFiGeneric.cpp, sets global initialized flag, starts network event task queue and calls
 // tcpip_adapter_init()
 extern void tcpipInit();
@@ -16,10 +21,17 @@ extern void tcpipInit();
 namespace esphome {
 namespace ethernet {
 
-static const char *TAG = "ethernet";
+static const char *const TAG = "ethernet";
 
 EthernetComponent *global_eth_component;
 
+#define ESPHL_ERROR_CHECK(err, message) \
+  if (err != ESP_OK) { \
+    ESP_LOGE(TAG, message ": (%d) %s", err, esp_err_to_name(err)); \
+    this->mark_failed(); \
+    return; \
+  }
+
 EthernetComponent::EthernetComponent() { global_eth_component = this; }
 void EthernetComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up Ethernet...");
@@ -31,103 +43,6 @@ void EthernetComponent::setup() {
     this->power_pin_->setup();
   }
 
-  this->start_connect_();
-
-#ifdef USE_MDNS
-  network_setup_mdns();
-#endif
-}
-void EthernetComponent::loop() {
-  const uint32_t now = millis();
-  if (!this->connected_ && !this->last_connected_ && now - this->connect_begin_ > 15000) {
-    ESP_LOGW(TAG, "Connecting via ethernet failed! Re-connecting...");
-    this->start_connect_();
-    return;
-  }
-
-  if (this->connected_ == this->last_connected_)
-    // nothing changed
-    return;
-
-  if (this->connected_) {
-    // connection established
-    ESP_LOGI(TAG, "Connected via Ethernet!");
-    this->dump_connect_params_();
-    this->status_clear_warning();
-  } else {
-    // connection lost
-    ESP_LOGW(TAG, "Connection via Ethernet lost! Re-connecting...");
-    this->start_connect_();
-  }
-
-  this->last_connected_ = this->connected_;
-
-  network_tick_mdns();
-}
-void EthernetComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Ethernet:");
-  this->dump_connect_params_();
-  LOG_PIN("  Power Pin: ", this->power_pin_);
-  ESP_LOGCONFIG(TAG, "  MDC Pin: %u", this->mdc_pin_);
-  ESP_LOGCONFIG(TAG, "  MDIO Pin: %u", this->mdio_pin_);
-  ESP_LOGCONFIG(TAG, "  Type: %s", this->type_ == ETHERNET_TYPE_LAN8720 ? "LAN8720" : "TLK110");
-}
-float EthernetComponent::get_setup_priority() const { return setup_priority::WIFI; }
-bool EthernetComponent::can_proceed() { return this->is_connected(); }
-IPAddress EthernetComponent::get_ip_address() {
-  tcpip_adapter_ip_info_t ip;
-  tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_ETH, &ip);
-  return IPAddress(ip.ip.addr);
-}
-
-void EthernetComponent::on_wifi_event_(system_event_id_t event, system_event_info_t info) {
-  const char *event_name;
-
-  switch (event) {
-    case SYSTEM_EVENT_ETH_START:
-      event_name = "ETH started";
-      break;
-    case SYSTEM_EVENT_ETH_STOP:
-      event_name = "ETH stopped";
-      this->connected_ = false;
-      break;
-    case SYSTEM_EVENT_ETH_CONNECTED:
-      event_name = "ETH connected";
-      break;
-    case SYSTEM_EVENT_ETH_DISCONNECTED:
-      event_name = "ETH disconnected";
-      this->connected_ = false;
-      break;
-    case SYSTEM_EVENT_ETH_GOT_IP:
-      event_name = "ETH Got IP";
-      this->connected_ = true;
-      break;
-    default:
-      return;
-  }
-
-  ESP_LOGV(TAG, "[Ethernet event] %s (num=%d)", event_name, event);
-}
-
-#define ESPHL_ERROR_CHECK(err, message) \
-  if (err != ESP_OK) { \
-    ESP_LOGE(TAG, message ": %d", err); \
-    this->mark_failed(); \
-    return; \
-  }
-
-void EthernetComponent::start_connect_() {
-  this->connect_begin_ = millis();
-  this->status_set_warning();
-
-  esp_err_t err;
-  if (this->initialized_) {
-    // already initialized
-    err = esp_eth_enable();
-    ESPHL_ERROR_CHECK(err, "ETH enable error");
-    return;
-  }
-
   switch (this->type_) {
     case ETHERNET_TYPE_LAN8720: {
       memcpy(&this->eth_config, &phy_lan8720_default_ethernet_config, sizeof(eth_config_t));
@@ -155,16 +70,111 @@ void EthernetComponent::start_connect_() {
 
   tcpipInit();
 
+  esp_err_t err;
   err = esp_eth_init(&this->eth_config);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "ETH init error: %d", err);
-    this->mark_failed();
-    return;
+  ESPHL_ERROR_CHECK(err, "ETH init error");
+  err = esp_eth_enable();
+  ESPHL_ERROR_CHECK(err, "ETH enable error");
+
+#ifdef USE_MDNS
+  network_setup_mdns();
+#endif
+}
+void EthernetComponent::loop() {
+  const uint32_t now = millis();
+
+  switch (this->state_) {
+    case EthernetComponentState::STOPPED:
+      if (this->started_) {
+        ESP_LOGI(TAG, "Starting ethernet connection");
+        this->state_ = EthernetComponentState::CONNECTING;
+        this->start_connect_();
+      }
+      break;
+    case EthernetComponentState::CONNECTING:
+      if (!this->started_) {
+        ESP_LOGI(TAG, "Stopped ethernet connection");
+        this->state_ = EthernetComponentState::STOPPED;
+      } else if (this->connected_) {
+        // connection established
+        ESP_LOGI(TAG, "Connected via Ethernet!");
+        this->state_ = EthernetComponentState::CONNECTED;
+
+        this->dump_connect_params_();
+        this->status_clear_warning();
+
+        network_tick_mdns();
+      } else if (now - this->connect_begin_ > 15000) {
+        ESP_LOGW(TAG, "Connecting via ethernet failed! Re-connecting...");
+        this->start_connect_();
+      }
+      break;
+    case EthernetComponentState::CONNECTED:
+      if (!this->started_) {
+        ESP_LOGI(TAG, "Stopped ethernet connection");
+        this->state_ = EthernetComponentState::STOPPED;
+      } else if (!this->connected_) {
+        ESP_LOGW(TAG, "Connection via Ethernet lost! Re-connecting...");
+        this->state_ = EthernetComponentState::CONNECTING;
+        this->start_connect_();
+      }
+      break;
+  }
+}
+void EthernetComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Ethernet:");
+  this->dump_connect_params_();
+  LOG_PIN("  Power Pin: ", this->power_pin_);
+  ESP_LOGCONFIG(TAG, "  MDC Pin: %u", this->mdc_pin_);
+  ESP_LOGCONFIG(TAG, "  MDIO Pin: %u", this->mdio_pin_);
+  ESP_LOGCONFIG(TAG, "  Type: %s", this->type_ == ETHERNET_TYPE_LAN8720 ? "LAN8720" : "TLK110");
+}
+float EthernetComponent::get_setup_priority() const { return setup_priority::WIFI; }
+bool EthernetComponent::can_proceed() { return this->is_connected(); }
+IPAddress EthernetComponent::get_ip_address() {
+  tcpip_adapter_ip_info_t ip;
+  tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_ETH, &ip);
+  return IPAddress(ip.ip.addr);
+}
+
+void EthernetComponent::on_wifi_event_(system_event_id_t event, system_event_info_t info) {
+  const char *event_name;
+
+  switch (event) {
+    case SYSTEM_EVENT_ETH_START:
+      event_name = "ETH started";
+      this->started_ = true;
+      break;
+    case SYSTEM_EVENT_ETH_STOP:
+      event_name = "ETH stopped";
+      this->started_ = false;
+      this->connected_ = false;
+      break;
+    case SYSTEM_EVENT_ETH_CONNECTED:
+      event_name = "ETH connected";
+      break;
+    case SYSTEM_EVENT_ETH_DISCONNECTED:
+      event_name = "ETH disconnected";
+      this->connected_ = false;
+      break;
+    case SYSTEM_EVENT_ETH_GOT_IP:
+      event_name = "ETH Got IP";
+      this->connected_ = true;
+      break;
+    default:
+      return;
   }
 
-  this->initialized_ = true;
+  ESP_LOGV(TAG, "[Ethernet event] %s (num=%d)", event_name, event);
+}
 
-  tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_ETH, App.get_name().c_str());
+void EthernetComponent::start_connect_() {
+  this->connect_begin_ = millis();
+  this->status_set_warning();
+
+  esp_err_t err;
+  err = tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_ETH, App.get_name().c_str());
+  ESPHL_ERROR_CHECK(err, "ETH set hostname error");
 
   tcpip_adapter_ip_info_t info;
   if (this->manual_ip_.has_value()) {
@@ -215,7 +225,7 @@ void EthernetComponent::eth_phy_power_enable_(bool enable) {
   delay(1);
   global_eth_component->orig_power_enable_fun_(enable);
 }
-bool EthernetComponent::is_connected() { return this->connected_ && this->last_connected_; }
+bool EthernetComponent::is_connected() { return this->state_ == EthernetComponentState::CONNECTED; }
 void EthernetComponent::dump_connect_params_() {
   tcpip_adapter_ip_info_t ip;
   tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_ETH, &ip);

esphome/components/ethernet/ethernet_component.h

@@ -26,6 +26,12 @@ struct ManualIP {
   IPAddress dns2;  ///< The second DNS server. 0.0.0.0 for default.
 };
 
+enum class EthernetComponentState {
+  STOPPED,
+  CONNECTING,
+  CONNECTED,
+};
+
 class EthernetComponent : public Component {
  public:
   EthernetComponent();
@@ -65,9 +71,9 @@ class EthernetComponent : public Component {
   eth_clock_mode_t clk_mode_{ETH_CLOCK_GPIO0_IN};
   optional<ManualIP> manual_ip_{};
 
-  bool initialized_{false};
+  bool started_{false};
   bool connected_{false};
-  bool last_connected_{false};
+  EthernetComponentState state_{EthernetComponentState::STOPPED};
   uint32_t connect_begin_;
   eth_config_t eth_config;
   eth_phy_power_enable_func orig_power_enable_fun_;

esphome/components/exposure_notifications/exposure_notifications.cpp

@@ -9,7 +9,7 @@ namespace exposure_notifications {
 
 using namespace esp32_ble_tracker;
 
-static const char *TAG = "exposure_notifications";
+static const char *const TAG = "exposure_notifications";
 
 bool ExposureNotificationTrigger::parse_device(const ESPBTDevice &device) {
   // See also https://blog.google/documents/70/Exposure_Notification_-_Bluetooth_Specification_v1.2.2.pdf

esphome/components/external_components/__init__.py

@@ -109,7 +109,15 @@ def _compute_destination_path(key: str) -> Path:
     return base_dir / h.hexdigest()[:8]
 
 
-def _handle_git_response(ret):
+def _run_git_command(cmd, cwd=None):
+    try:
+        ret = subprocess.run(cmd, cwd=cwd, capture_output=True, check=False)
+    except FileNotFoundError as err:
+        raise cv.Invalid(
+            "git is not installed but required for external_components.\n"
+            "Please see https://git-scm.com/book/en/v2/Getting-Started-Installing-Git for installing git"
+        ) from err
+
     if ret.returncode != 0 and ret.stderr:
         err_str = ret.stderr.decode("utf-8")
         lines = [x.strip() for x in err_str.splitlines()]
@@ -118,46 +126,61 @@ def _handle_git_response(ret):
         raise cv.Invalid(err_str)
 
 
+def _process_git_config(config: dict, refresh) -> str:
+    key = f"{config[CONF_URL]}@{config.get(CONF_REF)}"
+    repo_dir = _compute_destination_path(key)
+    if not repo_dir.is_dir():
+        _LOGGER.info("Cloning %s", key)
+        _LOGGER.debug("Location: %s", repo_dir)
+        cmd = ["git", "clone", "--depth=1"]
+        if CONF_REF in config:
+            cmd += ["--branch", config[CONF_REF]]
+        cmd += ["--", config[CONF_URL], str(repo_dir)]
+        _run_git_command(cmd)
+
+    else:
+        # Check refresh needed
+        file_timestamp = Path(repo_dir / ".git" / "FETCH_HEAD")
+        # On first clone, FETCH_HEAD does not exists
+        if not file_timestamp.exists():
+            file_timestamp = Path(repo_dir / ".git" / "HEAD")
+        age = datetime.datetime.now() - datetime.datetime.fromtimestamp(
+            file_timestamp.stat().st_mtime
+        )
+        if age.seconds > refresh.total_seconds:
+            _LOGGER.info("Updating %s", key)
+            _LOGGER.debug("Location: %s", repo_dir)
+            # Stash local changes (if any)
+            _run_git_command(
+                ["git", "stash", "push", "--include-untracked"], str(repo_dir)
+            )
+            # Fetch remote ref
+            cmd = ["git", "fetch", "--", "origin"]
+            if CONF_REF in config:
+                cmd.append(config[CONF_REF])
+            _run_git_command(cmd, str(repo_dir))
+            # Hard reset to FETCH_HEAD (short-lived git ref corresponding to most recent fetch)
+            _run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], str(repo_dir))
+
+    if (repo_dir / "esphome" / "components").is_dir():
+        components_dir = repo_dir / "esphome" / "components"
+    elif (repo_dir / "components").is_dir():
+        components_dir = repo_dir / "components"
+    else:
+        raise cv.Invalid(
+            "Could not find components folder for source. Please check the source contains a 'components' or 'esphome/components' folder"
+        )
+
+    return components_dir
+
+
 def _process_single_config(config: dict):
     conf = config[CONF_SOURCE]
     if conf[CONF_TYPE] == TYPE_GIT:
-        key = f"{conf[CONF_URL]}@{conf.get(CONF_REF)}"
-        repo_dir = _compute_destination_path(key)
-        if not repo_dir.is_dir():
-            cmd = ["git", "clone", "--depth=1"]
-            if CONF_REF in conf:
-                cmd += ["--branch", conf[CONF_REF]]
-            cmd += [conf[CONF_URL], str(repo_dir)]
-            ret = subprocess.run(cmd, capture_output=True, check=False)
-            _handle_git_response(ret)
-
-        else:
-            # Check refresh needed
-            file_timestamp = Path(repo_dir / ".git" / "FETCH_HEAD")
-            # On first clone, FETCH_HEAD does not exists
-            if not file_timestamp.exists():
-                file_timestamp = Path(repo_dir / ".git" / "HEAD")
-            age = datetime.datetime.now() - datetime.datetime.fromtimestamp(
-                file_timestamp.stat().st_mtime
+        with cv.prepend_path([CONF_SOURCE]):
+            components_dir = _process_git_config(
+                config[CONF_SOURCE], config[CONF_REFRESH]
             )
-            if age.seconds > config[CONF_REFRESH].total_seconds:
-                _LOGGER.info("Executing git pull %s", key)
-                cmd = ["git", "pull"]
-                ret = subprocess.run(
-                    cmd, cwd=repo_dir, capture_output=True, check=False
-                )
-                _handle_git_response(ret)
-
-        if (repo_dir / "esphome" / "components").is_dir():
-            components_dir = repo_dir / "esphome" / "components"
-        elif (repo_dir / "components").is_dir():
-            components_dir = repo_dir / "components"
-        else:
-            raise cv.Invalid(
-                "Could not find components folder for source. Please check the source contains a 'components' or 'esphome/components' folder",
-                [CONF_SOURCE],
-            )
-
     elif conf[CONF_TYPE] == TYPE_LOCAL:
         components_dir = Path(CORE.relative_config_path(conf[CONF_PATH]))
     else:

esphome/components/ezo/ezo.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace ezo {
 
-static const char *TAG = "ezo.sensor";
+static const char *const TAG = "ezo.sensor";
 
 static const uint16_t EZO_STATE_WAIT = 1;
 static const uint16_t EZO_STATE_SEND_TEMP = 2;

esphome/components/ezo/ezo.h

@@ -18,8 +18,8 @@ class EZOSensor : public sensor::Sensor, public PollingComponent, public i2c::I2
   void set_tempcomp_value(float temp);
 
  protected:
-  unsigned long start_time_ = 0;
-  unsigned long wait_time_ = 0;
+  uint32_t start_time_ = 0;
+  uint32_t wait_time_ = 0;
   uint16_t state_ = 0;
   float tempcomp_;
 };

esphome/components/fan/automation.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace fan {
 
-static const char *TAG = "fan.automation";
+static const char *const TAG = "fan.automation";
 
 }  // namespace fan
 }  // namespace esphome

esphome/components/fan/fan_helpers.cpp

@@ -6,7 +6,7 @@ namespace fan {
 
 FanSpeed speed_level_to_enum(int speed_level, int supported_speed_levels) {
   const auto speed_ratio = static_cast<float>(speed_level) / (supported_speed_levels + 1);
-  const auto legacy_level = static_cast<int>(clamp(ceilf(speed_ratio * 3), 1, 3));
+  const auto legacy_level = clamp<int>(static_cast<int>(ceilf(speed_ratio * 3)), 1, 3);
   return static_cast<FanSpeed>(legacy_level - 1);
 }
 

esphome/components/fan/fan_state.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace fan {
 
-static const char *TAG = "fan";
+static const char *const TAG = "fan";
 
 const FanTraits &FanState::get_traits() const { return this->traits_; }
 void FanState::set_traits(const FanTraits &traits) { this->traits_ = traits; }
@@ -54,7 +54,7 @@ void FanStateCall::perform() const {
   }
   if (this->speed_.has_value()) {
     const int speed_count = this->state_->get_traits().supported_speed_count();
-    this->state_->speed = static_cast<int>(clamp(*this->speed_, 1, speed_count));
+    this->state_->speed = clamp(*this->speed_, 1, speed_count);
   }
 
   FanStateRTCState saved{};

esphome/components/fastled_base/fastled_light.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace fastled_base {
 
-static const char *TAG = "fastled";
+static const char *const TAG = "fastled";
 
 void FastLEDLightOutput::setup() {
   ESP_LOGCONFIG(TAG, "Setting up FastLED light...");

esphome/components/fingerprint_grow/fingerprint_grow.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace fingerprint_grow {
 
-static const char* TAG = "fingerprint_grow";
+static const char *const TAG = "fingerprint_grow";
 
 // Based on Adafruit's library: https://github.com/adafruit/Adafruit-Fingerprint-Sensor-Library
 

esphome/components/font/__init__.py

@@ -110,7 +110,7 @@ async def to_code(config):
         _, (offset_x, offset_y) = font.font.getsize(glyph)
         width, height = mask.size
         width8 = ((width + 7) // 8) * 8
-        glyph_data = [0 for _ in range(height * width8 // 8)]  # noqa: F812
+        glyph_data = [0] * (height * width8 // 8)
         for y in range(height):
             for x in range(width):
                 if not mask.getpixel((x, y)):

esphome/components/fujitsu_general/fujitsu_general.cpp

@@ -5,10 +5,11 @@ namespace fujitsu_general {
 
 // bytes' bits are reversed for fujitsu, so nibbles are ordered 1, 0, 3, 2, 5, 4, etc...
 
-#define SET_NIBBLE(message, nibble, value) (message[nibble / 2] |= (value & 0b00001111) << ((nibble % 2) ? 0 : 4))
-#define GET_NIBBLE(message, nibble) ((message[nibble / 2] >> ((nibble % 2) ? 0 : 4)) & 0b00001111)
+#define SET_NIBBLE(message, nibble, value) \
+  ((message)[(nibble) / 2] |= ((value) &0b00001111) << (((nibble) % 2) ? 0 : 4))
+#define GET_NIBBLE(message, nibble) (((message)[(nibble) / 2] >> (((nibble) % 2) ? 0 : 4)) & 0b00001111)
 
-static const char* TAG = "fujitsu_general.climate";
+static const char *const TAG = "fujitsu_general.climate";
 
 // Common header
 const uint8_t FUJITSU_GENERAL_COMMON_LENGTH = 6;
@@ -109,7 +110,7 @@ void FujitsuGeneralClimate::transmit_state() {
 
   // Set temperature
   uint8_t temperature_clamped =
-      (uint8_t) roundf(clamp(this->target_temperature, FUJITSU_GENERAL_TEMP_MIN, FUJITSU_GENERAL_TEMP_MAX));
+      (uint8_t) roundf(clamp<float>(this->target_temperature, FUJITSU_GENERAL_TEMP_MIN, FUJITSU_GENERAL_TEMP_MAX));
   uint8_t temperature_offset = temperature_clamped - FUJITSU_GENERAL_TEMP_MIN;
   SET_NIBBLE(remote_state, FUJITSU_GENERAL_TEMPERATURE_NIBBLE, temperature_offset);
 
@@ -202,7 +203,7 @@ void FujitsuGeneralClimate::transmit_off_() {
   this->power_ = false;
 }
 
-void FujitsuGeneralClimate::transmit_(uint8_t const* message, uint8_t length) {
+void FujitsuGeneralClimate::transmit_(uint8_t const *message, uint8_t length) {
   ESP_LOGV(TAG, "Transmit message length %d", length);
 
   auto transmit = this->transmitter_->transmit();
@@ -231,7 +232,7 @@ void FujitsuGeneralClimate::transmit_(uint8_t const* message, uint8_t length) {
   transmit.perform();
 }
 
-uint8_t FujitsuGeneralClimate::checksum_state_(uint8_t const* message) {
+uint8_t FujitsuGeneralClimate::checksum_state_(uint8_t const *message) {
   uint8_t checksum = 0;
   for (uint8_t i = 7; i < FUJITSU_GENERAL_STATE_MESSAGE_LENGTH - 1; ++i) {
     checksum += message[i];
@@ -239,7 +240,7 @@ uint8_t FujitsuGeneralClimate::checksum_state_(uint8_t const* message) {
   return 256 - checksum;
 }
 
-uint8_t FujitsuGeneralClimate::checksum_util_(uint8_t const* message) { return 255 - message[5]; }
+uint8_t FujitsuGeneralClimate::checksum_util_(uint8_t const *message) { return 255 - message[5]; }
 
 bool FujitsuGeneralClimate::on_receive(remote_base::RemoteReceiveData data) {
   ESP_LOGV(TAG, "Received IR message");

esphome/components/fujitsu_general/fujitsu_general.h

@@ -66,13 +66,13 @@ class FujitsuGeneralClimate : public climate_ir::ClimateIR {
   bool on_receive(remote_base::RemoteReceiveData data) override;
 
   /// Transmit message as IR pulses
-  void transmit_(uint8_t const* message, uint8_t length);
+  void transmit_(uint8_t const *message, uint8_t length);
 
   /// Calculate checksum for a state message
-  uint8_t checksum_state_(uint8_t const* message);
+  uint8_t checksum_state_(uint8_t const *message);
 
   /// Calculate cecksum for a util message
-  uint8_t checksum_util_(uint8_t const* message);
+  uint8_t checksum_util_(uint8_t const *message);
 
   // true if currently on - fujitsus transmit an on flag on when the remote moves from off to on
   bool power_{false};

esphome/components/gpio/binary_sensor/gpio_binary_sensor.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace gpio {
 
-static const char *TAG = "gpio.binary_sensor";
+static const char *const TAG = "gpio.binary_sensor";
 
 void GPIOBinarySensor::setup() {
   this->pin_->setup();

esphome/components/gpio/output/gpio_binary_output.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace gpio {
 
-static const char *TAG = "gpio.output";
+static const char *const TAG = "gpio.output";
 
 void GPIOBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "GPIO Binary Output:");

esphome/components/gpio/switch/gpio_switch.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace gpio {
 
-static const char *TAG = "switch.gpio";
+static const char *const TAG = "switch.gpio";
 
 float GPIOSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 void GPIOSwitch::setup() {

esphome/components/gps/gps.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace gps {
 
-static const char *TAG = "gps";
+static const char *const TAG = "gps";
 
 TinyGPSPlus &GPSListener::get_tiny_gps() { return this->parent_->get_tiny_gps(); }
 

esphome/components/gps/time/gps_time.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace gps {
 
-static const char *TAG = "gps.time";
+static const char *const TAG = "gps.time";
 
 void GPSTime::from_tiny_gps_(TinyGPSPlus &tiny_gps) {
   if (!tiny_gps.time.isValid() || !tiny_gps.date.isValid())

esphome/components/havells_solar/havells_solar.cpp

@@ -0,0 +1,165 @@
+#include "havells_solar.h"
+#include "havells_solar_registers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace havells_solar {
+
+static const char *const TAG = "havells_solar";
+
+static const uint8_t MODBUS_CMD_READ_IN_REGISTERS = 0x03;
+static const uint8_t MODBUS_REGISTER_COUNT = 48;  // 48 x 16-bit registers
+
+void HavellsSolar::on_modbus_data(const std::vector<uint8_t> &data) {
+  if (data.size() < MODBUS_REGISTER_COUNT * 2) {
+    ESP_LOGW(TAG, "Invalid size for HavellsSolar!");
+    return;
+  }
+
+  /* Usage: returns the float value of 1 register read by modbus
+            Arg1: Register address * number of bytes per register
+            Arg2: Multiplier for final register value
+  */
+  auto havells_solar_get_2_registers = [&](size_t i, float unit) -> float {
+    uint32_t temp = encode_uint32(data[i], data[i + 1], data[i + 2], data[i + 3]);
+    return temp * unit;
+  };
+
+  /* Usage: returns the float value of 2 registers read by modbus
+            Arg1: Register address * number of bytes per register
+            Arg2: Multiplier for final register value
+  */
+  auto havells_solar_get_1_register = [&](size_t i, float unit) -> float {
+    uint16_t temp = encode_uint16(data[i], data[i + 1]);
+    return temp * unit;
+  };
+
+  for (uint8_t i = 0; i < 3; i++) {
+    auto phase = this->phases_[i];
+    if (!phase.setup)
+      continue;
+
+    float voltage = havells_solar_get_1_register(HAVELLS_PHASE_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT);
+    float current = havells_solar_get_1_register(HAVELLS_PHASE_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT);
+
+    if (phase.voltage_sensor_ != nullptr)
+      phase.voltage_sensor_->publish_state(voltage);
+    if (phase.current_sensor_ != nullptr)
+      phase.current_sensor_->publish_state(current);
+  }
+
+  for (uint8_t i = 0; i < 2; i++) {
+    auto pv = this->pvs_[i];
+    if (!pv.setup)
+      continue;
+
+    float voltage = havells_solar_get_1_register(HAVELLS_PV_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT);
+    float current = havells_solar_get_1_register(HAVELLS_PV_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT);
+    float active_power = havells_solar_get_1_register(HAVELLS_PV_1_POWER * 2 + (i * 2), MULTIPLY_TEN_UNIT);
+    float voltage_sampled_by_secondary_cpu =
+        havells_solar_get_1_register(HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU * 2 + (i * 2), ONE_DEC_UNIT);
+    float insulation_of_p_to_ground =
+        havells_solar_get_1_register(HAVELLS_PV1_INSULATION_OF_P_TO_GROUND * 2 + (i * 2), NO_DEC_UNIT);
+
+    if (pv.voltage_sensor_ != nullptr)
+      pv.voltage_sensor_->publish_state(voltage);
+    if (pv.current_sensor_ != nullptr)
+      pv.current_sensor_->publish_state(current);
+    if (pv.active_power_sensor_ != nullptr)
+      pv.active_power_sensor_->publish_state(active_power);
+    if (pv.voltage_sampled_by_secondary_cpu_sensor_ != nullptr)
+      pv.voltage_sampled_by_secondary_cpu_sensor_->publish_state(voltage_sampled_by_secondary_cpu);
+    if (pv.insulation_of_p_to_ground_sensor_ != nullptr)
+      pv.insulation_of_p_to_ground_sensor_->publish_state(insulation_of_p_to_ground);
+  }
+
+  float frequency = havells_solar_get_1_register(HAVELLS_GRID_FREQUENCY * 2, TWO_DEC_UNIT);
+  float active_power = havells_solar_get_1_register(HAVELLS_SYSTEM_ACTIVE_POWER * 2, MULTIPLY_TEN_UNIT);
+  float reactive_power = havells_solar_get_1_register(HAVELLS_SYSTEM_REACTIVE_POWER * 2, TWO_DEC_UNIT);
+  float today_production = havells_solar_get_1_register(HAVELLS_TODAY_PRODUCTION * 2, TWO_DEC_UNIT);
+  float total_energy_production = havells_solar_get_2_registers(HAVELLS_TOTAL_ENERGY_PRODUCTION * 2, NO_DEC_UNIT);
+  float total_generation_time = havells_solar_get_2_registers(HAVELLS_TOTAL_GENERATION_TIME * 2, NO_DEC_UNIT);
+  float today_generation_time = havells_solar_get_1_register(HAVELLS_TODAY_GENERATION_TIME * 2, NO_DEC_UNIT);
+  float inverter_module_temp = havells_solar_get_1_register(HAVELLS_INVERTER_MODULE_TEMP * 2, NO_DEC_UNIT);
+  float inverter_inner_temp = havells_solar_get_1_register(HAVELLS_INVERTER_INNER_TEMP * 2, NO_DEC_UNIT);
+  float inverter_bus_voltage = havells_solar_get_1_register(HAVELLS_INVERTER_BUS_VOLTAGE * 2, NO_DEC_UNIT);
+  float insulation_pv_n_to_ground = havells_solar_get_1_register(HAVELLS_INSULATION_OF_PV_N_TO_GROUND * 2, NO_DEC_UNIT);
+  float gfci_value = havells_solar_get_1_register(HAVELLS_GFCI_VALUE * 2, NO_DEC_UNIT);
+  float dci_of_r = havells_solar_get_1_register(HAVELLS_DCI_OF_R * 2, NO_DEC_UNIT);
+  float dci_of_s = havells_solar_get_1_register(HAVELLS_DCI_OF_S * 2, NO_DEC_UNIT);
+  float dci_of_t = havells_solar_get_1_register(HAVELLS_DCI_OF_T * 2, NO_DEC_UNIT);
+
+  if (this->frequency_sensor_ != nullptr)
+    this->frequency_sensor_->publish_state(frequency);
+  if (this->active_power_sensor_ != nullptr)
+    this->active_power_sensor_->publish_state(active_power);
+  if (this->reactive_power_sensor_ != nullptr)
+    this->reactive_power_sensor_->publish_state(reactive_power);
+  if (this->today_production_sensor_ != nullptr)
+    this->today_production_sensor_->publish_state(today_production);
+  if (this->total_energy_production_sensor_ != nullptr)
+    this->total_energy_production_sensor_->publish_state(total_energy_production);
+  if (this->total_generation_time_sensor_ != nullptr)
+    this->total_generation_time_sensor_->publish_state(total_generation_time);
+  if (this->today_generation_time_sensor_ != nullptr)
+    this->today_generation_time_sensor_->publish_state(today_generation_time);
+  if (this->inverter_module_temp_sensor_ != nullptr)
+    this->inverter_module_temp_sensor_->publish_state(inverter_module_temp);
+  if (this->inverter_inner_temp_sensor_ != nullptr)
+    this->inverter_inner_temp_sensor_->publish_state(inverter_inner_temp);
+  if (this->inverter_bus_voltage_sensor_ != nullptr)
+    this->inverter_bus_voltage_sensor_->publish_state(inverter_bus_voltage);
+  if (this->insulation_pv_n_to_ground_sensor_ != nullptr)
+    this->insulation_pv_n_to_ground_sensor_->publish_state(insulation_pv_n_to_ground);
+  if (this->gfci_value_sensor_ != nullptr)
+    this->gfci_value_sensor_->publish_state(gfci_value);
+  if (this->dci_of_r_sensor_ != nullptr)
+    this->dci_of_r_sensor_->publish_state(dci_of_r);
+  if (this->dci_of_s_sensor_ != nullptr)
+    this->dci_of_s_sensor_->publish_state(dci_of_s);
+  if (this->dci_of_t_sensor_ != nullptr)
+    this->dci_of_t_sensor_->publish_state(dci_of_t);
+}
+
+void HavellsSolar::update() { this->send(MODBUS_CMD_READ_IN_REGISTERS, 0, MODBUS_REGISTER_COUNT); }
+void HavellsSolar::dump_config() {
+  ESP_LOGCONFIG(TAG, "HAVELLS Solar:");
+  ESP_LOGCONFIG(TAG, "  Address: 0x%02X", this->address_);
+  for (uint8_t i = 0; i < 3; i++) {
+    auto phase = this->phases_[i];
+    if (!phase.setup)
+      continue;
+    ESP_LOGCONFIG(TAG, "  Phase %c", i + 'A');
+    LOG_SENSOR("    ", "Voltage", phase.voltage_sensor_);
+    LOG_SENSOR("    ", "Current", phase.current_sensor_);
+  }
+  for (uint8_t i = 0; i < 2; i++) {
+    auto pv = this->pvs_[i];
+    if (!pv.setup)
+      continue;
+    ESP_LOGCONFIG(TAG, "  PV %d", i + 1);
+    LOG_SENSOR("    ", "Voltage", pv.voltage_sensor_);
+    LOG_SENSOR("    ", "Current", pv.current_sensor_);
+    LOG_SENSOR("    ", "Active Power", pv.active_power_sensor_);
+    LOG_SENSOR("    ", "Voltage Sampled By Secondary CPU", pv.voltage_sampled_by_secondary_cpu_sensor_);
+    LOG_SENSOR("    ", "Insulation Of PV+ To Ground", pv.insulation_of_p_to_ground_sensor_);
+  }
+  LOG_SENSOR("  ", "Frequency", this->frequency_sensor_);
+  LOG_SENSOR("  ", "Active Power", this->active_power_sensor_);
+  LOG_SENSOR("  ", "Reactive Power", this->reactive_power_sensor_);
+  LOG_SENSOR("  ", "Today Generation", this->today_production_sensor_);
+  LOG_SENSOR("  ", "Total Generation", this->total_energy_production_sensor_);
+  LOG_SENSOR("  ", "Total Generation Time", this->total_generation_time_sensor_);
+  LOG_SENSOR("  ", "Today Generation Time", this->today_generation_time_sensor_);
+  LOG_SENSOR("  ", "Inverter Module Temp", this->inverter_module_temp_sensor_);
+  LOG_SENSOR("  ", "Inverter Inner Temp", this->inverter_inner_temp_sensor_);
+  LOG_SENSOR("  ", "Inverter Bus Voltage", this->inverter_bus_voltage_sensor_);
+  LOG_SENSOR("  ", "Insulation Of PV- To Ground", this->insulation_pv_n_to_ground_sensor_);
+  LOG_SENSOR("  ", "GFCI Value", this->gfci_value_sensor_);
+  LOG_SENSOR("  ", "DCI Of R", this->dci_of_r_sensor_);
+  LOG_SENSOR("  ", "DCI Of S", this->dci_of_s_sensor_);
+  LOG_SENSOR("  ", "DCI Of T", this->dci_of_t_sensor_);
+}
+
+}  // namespace havells_solar
+}  // namespace esphome

esphome/components/havells_solar/havells_solar.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/modbus/modbus.h"
+
+namespace esphome {
+namespace havells_solar {
+
+class HavellsSolar : public PollingComponent, public modbus::ModbusDevice {
+ public:
+  void set_voltage_sensor(uint8_t phase, sensor::Sensor *voltage_sensor) {
+    this->phases_[phase].setup = true;
+    this->phases_[phase].voltage_sensor_ = voltage_sensor;
+  }
+  void set_current_sensor(uint8_t phase, sensor::Sensor *current_sensor) {
+    this->phases_[phase].setup = true;
+    this->phases_[phase].current_sensor_ = current_sensor;
+  }
+  void set_voltage_sensor_pv(uint8_t pv, sensor::Sensor *voltage_sensor) {
+    this->pvs_[pv].setup = true;
+    this->pvs_[pv].voltage_sensor_ = voltage_sensor;
+  }
+  void set_current_sensor_pv(uint8_t pv, sensor::Sensor *current_sensor) {
+    this->pvs_[pv].setup = true;
+    this->pvs_[pv].current_sensor_ = current_sensor;
+  }
+  void set_active_power_sensor_pv(uint8_t pv, sensor::Sensor *active_power_sensor) {
+    this->pvs_[pv].setup = true;
+    this->pvs_[pv].active_power_sensor_ = active_power_sensor;
+  }
+  void set_voltage_sampled_by_secondary_cpu_sensor_pv(uint8_t pv,
+                                                      sensor::Sensor *voltage_sampled_by_secondary_cpu_sensor) {
+    this->pvs_[pv].setup = true;
+    this->pvs_[pv].voltage_sampled_by_secondary_cpu_sensor_ = voltage_sampled_by_secondary_cpu_sensor;
+  }
+  void set_insulation_of_p_to_ground_sensor_pv(uint8_t pv, sensor::Sensor *insulation_of_p_to_ground_sensor) {
+    this->pvs_[pv].setup = true;
+    this->pvs_[pv].insulation_of_p_to_ground_sensor_ = insulation_of_p_to_ground_sensor;
+  }
+  void set_frequency_sensor(sensor::Sensor *frequency_sensor) { this->frequency_sensor_ = frequency_sensor; }
+  void set_active_power_sensor(sensor::Sensor *active_power_sensor) {
+    this->active_power_sensor_ = active_power_sensor;
+  }
+  void set_reactive_power_sensor(sensor::Sensor *reactive_power_sensor) {
+    this->reactive_power_sensor_ = reactive_power_sensor;
+  }
+  void set_today_production_sensor(sensor::Sensor *today_production_sensor) {
+    this->today_production_sensor_ = today_production_sensor;
+  }
+  void set_total_energy_production_sensor(sensor::Sensor *total_energy_production_sensor) {
+    this->total_energy_production_sensor_ = total_energy_production_sensor;
+  }
+  void set_total_generation_time_sensor(sensor::Sensor *total_generation_time_sensor) {
+    this->total_generation_time_sensor_ = total_generation_time_sensor;
+  }
+  void set_today_generation_time_sensor(sensor::Sensor *today_generation_time_sensor) {
+    this->today_generation_time_sensor_ = today_generation_time_sensor;
+  }
+  void set_inverter_module_temp_sensor(sensor::Sensor *inverter_module_temp_sensor) {
+    this->inverter_module_temp_sensor_ = inverter_module_temp_sensor;
+  }
+  void set_inverter_inner_temp_sensor(sensor::Sensor *inverter_inner_temp_sensor) {
+    this->inverter_inner_temp_sensor_ = inverter_inner_temp_sensor;
+  }
+  void set_inverter_bus_voltage_sensor(sensor::Sensor *inverter_bus_voltage_sensor) {
+    this->inverter_bus_voltage_sensor_ = inverter_bus_voltage_sensor;
+  }
+  void set_insulation_pv_n_to_ground_sensor(sensor::Sensor *insulation_pv_n_to_ground_sensor) {
+    this->insulation_pv_n_to_ground_sensor_ = insulation_pv_n_to_ground_sensor;
+  }
+  void set_gfci_value_sensor(sensor::Sensor *gfci_value_sensor) { this->gfci_value_sensor_ = gfci_value_sensor; }
+  void set_dci_of_r_sensor(sensor::Sensor *dci_of_r_sensor) { this->dci_of_r_sensor_ = dci_of_r_sensor; }
+  void set_dci_of_s_sensor(sensor::Sensor *dci_of_s_sensor) { this->dci_of_s_sensor_ = dci_of_s_sensor; }
+  void set_dci_of_t_sensor(sensor::Sensor *dci_of_t_sensor) { this->dci_of_t_sensor_ = dci_of_t_sensor; }
+
+  void update() override;
+
+  void on_modbus_data(const std::vector<uint8_t> &data) override;
+
+  void dump_config() override;
+
+ protected:
+  struct HAVELLSPhase {
+    bool setup{false};
+    sensor::Sensor *voltage_sensor_{nullptr};
+    sensor::Sensor *current_sensor_{nullptr};
+  } phases_[3];
+  struct HAVELLSPV {
+    bool setup{false};
+    sensor::Sensor *voltage_sensor_{nullptr};
+    sensor::Sensor *current_sensor_{nullptr};
+    sensor::Sensor *active_power_sensor_{nullptr};
+    sensor::Sensor *voltage_sampled_by_secondary_cpu_sensor_{nullptr};
+    sensor::Sensor *insulation_of_p_to_ground_sensor_{nullptr};
+  } pvs_[2];
+  sensor::Sensor *frequency_sensor_{nullptr};
+  sensor::Sensor *active_power_sensor_{nullptr};
+  sensor::Sensor *reactive_power_sensor_{nullptr};
+  sensor::Sensor *today_production_sensor_{nullptr};
+  sensor::Sensor *total_energy_production_sensor_{nullptr};
+  sensor::Sensor *total_generation_time_sensor_{nullptr};
+  sensor::Sensor *today_generation_time_sensor_{nullptr};
+  sensor::Sensor *inverter_module_temp_sensor_{nullptr};
+  sensor::Sensor *inverter_inner_temp_sensor_{nullptr};
+  sensor::Sensor *inverter_bus_voltage_sensor_{nullptr};
+  sensor::Sensor *insulation_pv_n_to_ground_sensor_{nullptr};
+  sensor::Sensor *gfci_value_sensor_{nullptr};
+  sensor::Sensor *dci_of_r_sensor_{nullptr};
+  sensor::Sensor *dci_of_s_sensor_{nullptr};
+  sensor::Sensor *dci_of_t_sensor_{nullptr};
+};
+
+}  // namespace havells_solar
+}  // namespace esphome

esphome/components/havells_solar/havells_solar_registers.h

@@ -0,0 +1,49 @@
+#pragma once
+namespace esphome {
+namespace havells_solar {
+
+static const float TWO_DEC_UNIT = 0.01;
+static const float ONE_DEC_UNIT = 0.1;
+static const float NO_DEC_UNIT = 1;
+static const float MULTIPLY_TEN_UNIT = 10;
+
+/* PV Input Message */
+static const uint16_t HAVELLS_PV_1_VOLTAGE = 0x0006;
+static const uint16_t HAVELLS_PV_1_CURRENT = 0x0007;
+static const uint16_t HAVELLS_PV_2_VOLTAGE = 0x0008;
+static const uint16_t HAVELLS_PV_2_CURRENT = 0x0009;
+static const uint16_t HAVELLS_PV_1_POWER = 0x000A;
+static const uint16_t HAVELLS_PV_2_POWER = 0x000B;
+
+/* Output Grid Message */
+static const uint16_t HAVELLS_SYSTEM_ACTIVE_POWER = 0x000C;
+static const uint16_t HAVELLS_SYSTEM_REACTIVE_POWER = 0x000D;
+static const uint16_t HAVELLS_GRID_FREQUENCY = 0x000E;
+static const uint16_t HAVELLS_PHASE_1_VOLTAGE = 0x000F;
+static const uint16_t HAVELLS_PHASE_1_CURRENT = 0x0010;
+static const uint16_t HAVELLS_PHASE_2_VOLTAGE = 0x0011;
+static const uint16_t HAVELLS_PHASE_2_CURRENT = 0x0012;
+static const uint16_t HAVELLS_PHASE_3_VOLTAGE = 0x0013;
+static const uint16_t HAVELLS_PHASE_3_CURRENT = 0x0014;
+
+/* Inverter Generation message */
+static const uint16_t HAVELLS_TOTAL_ENERGY_PRODUCTION = 0x0015;
+static const uint16_t HAVELLS_TOTAL_GENERATION_TIME = 0x0017;
+static const uint16_t HAVELLS_TODAY_PRODUCTION = 0x0019;
+static const uint16_t HAVELLS_TODAY_GENERATION_TIME = 0x001A;
+
+/* Inverter inner message */
+static const uint16_t HAVELLS_INVERTER_MODULE_TEMP = 0x001B;
+static const uint16_t HAVELLS_INVERTER_INNER_TEMP = 0x001C;
+static const uint16_t HAVELLS_INVERTER_BUS_VOLTAGE = 0x001D;
+static const uint16_t HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU = 0x001E;
+static const uint16_t HAVELLS_PV2_VOLTAGE_SAMPLED_BY_SECONDARY_CPU = 0x001F;
+static const uint16_t HAVELLS_PV1_INSULATION_OF_P_TO_GROUND = 0x0024;
+static const uint16_t HAVELLS_PV2_INSULATION_OF_P_TO_GROUND = 0x0025;
+static const uint16_t HAVELLS_INSULATION_OF_PV_N_TO_GROUND = 0x0026;
+static const uint16_t HAVELLS_GFCI_VALUE = 0x002A;
+static const uint16_t HAVELLS_DCI_OF_R = 0x002B;
+static const uint16_t HAVELLS_DCI_OF_S = 0x002C;
+static const uint16_t HAVELLS_DCI_OF_T = 0x002D;
+}  // namespace havells_solar
+}  // namespace esphome

esphome/components/havells_solar/sensor.py

@@ -0,0 +1,296 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import sensor, modbus
+from esphome.const import (
+    CONF_ACTIVE_POWER,
+    CONF_CURRENT,
+    CONF_FREQUENCY,
+    CONF_ID,
+    CONF_REACTIVE_POWER,
+    CONF_VOLTAGE,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_VOLTAGE,
+    ICON_CURRENT_AC,
+    ICON_EMPTY,
+    LAST_RESET_TYPE_AUTO,
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_NONE,
+    UNIT_AMPERE,
+    UNIT_DEGREES,
+    UNIT_HERTZ,
+    UNIT_MINUTE,
+    UNIT_VOLT,
+    UNIT_VOLT_AMPS_REACTIVE,
+    UNIT_WATT,
+)
+
+CONF_PHASE_A = "phase_a"
+CONF_PHASE_B = "phase_b"
+CONF_PHASE_C = "phase_c"
+CONF_ENERGY_PRODUCTION_DAY = "energy_production_day"
+CONF_TOTAL_ENERGY_PRODUCTION = "total_energy_production"
+CONF_TOTAL_GENERATION_TIME = "total_generation_time"
+CONF_TODAY_GENERATION_TIME = "today_generation_time"
+CONF_PV1 = "pv1"
+CONF_PV2 = "pv2"
+UNIT_KILOWATT_HOURS = "kWh"
+UNIT_HOURS = "h"
+UNIT_KOHM = "kΩ"
+UNIT_MILLIAMPERE = "mA"
+
+
+CONF_INVERTER_MODULE_TEMP = "inverter_module_temp"
+CONF_INVERTER_INNER_TEMP = "inverter_inner_temp"
+CONF_INVERTER_BUS_VOLTAGE = "inverter_bus_voltage"
+CONF_VOLTAGE_SAMPLED_BY_SECONDARY_CPU = "voltage_sampled_by_secondary_cpu"
+CONF_INSULATION_OF_P_TO_GROUND = "insulation_of_p_to_ground"
+CONF_INSULATION_OF_PV_N_TO_GROUND = "insulation_of_pv_n_to_ground"
+CONF_GFCI_VALUE = "gfci_value"
+CONF_DCI_OF_R = "dci_of_r"
+CONF_DCI_OF_S = "dci_of_s"
+CONF_DCI_OF_T = "dci_of_t"
+
+
+AUTO_LOAD = ["modbus"]
+CODEOWNERS = ["@sourabhjaiswal"]
+
+havells_solar_ns = cg.esphome_ns.namespace("havells_solar")
+HavellsSolar = havells_solar_ns.class_(
+    "HavellsSolar", cg.PollingComponent, modbus.ModbusDevice
+)
+
+PHASE_SENSORS = {
+    CONF_VOLTAGE: sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE),
+    CONF_CURRENT: sensor.sensor_schema(
+        UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT
+    ),
+}
+PV_SENSORS = {
+    CONF_VOLTAGE: sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE),
+    CONF_CURRENT: sensor.sensor_schema(
+        UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT, STATE_CLASS_MEASUREMENT
+    ),
+    CONF_ACTIVE_POWER: sensor.sensor_schema(
+        UNIT_WATT, ICON_EMPTY, 0, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+    ),
+    CONF_VOLTAGE_SAMPLED_BY_SECONDARY_CPU: sensor.sensor_schema(
+        UNIT_VOLT, ICON_EMPTY, 0, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+    ),
+    CONF_INSULATION_OF_P_TO_GROUND: sensor.sensor_schema(
+        UNIT_KOHM, ICON_EMPTY, 0, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+    ),
+}
+
+PHASE_SCHEMA = cv.Schema(
+    {cv.Optional(sensor): schema for sensor, schema in PHASE_SENSORS.items()}
+)
+PV_SCHEMA = cv.Schema(
+    {cv.Optional(sensor): schema for sensor, schema in PV_SENSORS.items()}
+)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(HavellsSolar),
+            cv.Optional(CONF_PHASE_A): PHASE_SCHEMA,
+            cv.Optional(CONF_PHASE_B): PHASE_SCHEMA,
+            cv.Optional(CONF_PHASE_C): PHASE_SCHEMA,
+            cv.Optional(CONF_PV1): PV_SCHEMA,
+            cv.Optional(CONF_PV2): PV_SCHEMA,
+            cv.Optional(CONF_FREQUENCY): sensor.sensor_schema(
+                UNIT_HERTZ,
+                ICON_CURRENT_AC,
+                2,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ACTIVE_POWER): sensor.sensor_schema(
+                UNIT_WATT, ICON_EMPTY, 0, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
+            ),
+            cv.Optional(CONF_REACTIVE_POWER): sensor.sensor_schema(
+                UNIT_VOLT_AMPS_REACTIVE,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_POWER,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_ENERGY_PRODUCTION_DAY): sensor.sensor_schema(
+                UNIT_KILOWATT_HOURS,
+                ICON_EMPTY,
+                2,
+                DEVICE_CLASS_ENERGY,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
+            ),
+            cv.Optional(CONF_TOTAL_ENERGY_PRODUCTION): sensor.sensor_schema(
+                UNIT_KILOWATT_HOURS,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_ENERGY,
+                STATE_CLASS_MEASUREMENT,
+                LAST_RESET_TYPE_AUTO,
+            ),
+            cv.Optional(CONF_TOTAL_GENERATION_TIME): sensor.sensor_schema(
+                UNIT_HOURS,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_NONE,
+            ),
+            cv.Optional(CONF_TODAY_GENERATION_TIME): sensor.sensor_schema(
+                UNIT_MINUTE,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_NONE,
+            ),
+            cv.Optional(CONF_INVERTER_MODULE_TEMP): sensor.sensor_schema(
+                UNIT_DEGREES,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_INVERTER_INNER_TEMP): sensor.sensor_schema(
+                UNIT_DEGREES,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_INVERTER_BUS_VOLTAGE): sensor.sensor_schema(
+                UNIT_VOLT,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_INSULATION_OF_PV_N_TO_GROUND): sensor.sensor_schema(
+                UNIT_KOHM,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_GFCI_VALUE): sensor.sensor_schema(
+                UNIT_MILLIAMPERE,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_DCI_OF_R): sensor.sensor_schema(
+                UNIT_MILLIAMPERE,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_DCI_OF_S): sensor.sensor_schema(
+                UNIT_MILLIAMPERE,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_DCI_OF_T): sensor.sensor_schema(
+                UNIT_MILLIAMPERE,
+                ICON_EMPTY,
+                0,
+                DEVICE_CLASS_EMPTY,
+                STATE_CLASS_MEASUREMENT,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("10s"))
+    .extend(modbus.modbus_device_schema(0x01))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await modbus.register_modbus_device(var, config)
+
+    if CONF_FREQUENCY in config:
+        sens = await sensor.new_sensor(config[CONF_FREQUENCY])
+        cg.add(var.set_frequency_sensor(sens))
+
+    if CONF_ACTIVE_POWER in config:
+        sens = await sensor.new_sensor(config[CONF_ACTIVE_POWER])
+        cg.add(var.set_active_power_sensor(sens))
+
+    if CONF_REACTIVE_POWER in config:
+        sens = await sensor.new_sensor(config[CONF_REACTIVE_POWER])
+        cg.add(var.set_reactive_power_sensor(sens))
+
+    if CONF_ENERGY_PRODUCTION_DAY in config:
+        sens = await sensor.new_sensor(config[CONF_ENERGY_PRODUCTION_DAY])
+        cg.add(var.set_today_production_sensor(sens))
+
+    if CONF_TOTAL_ENERGY_PRODUCTION in config:
+        sens = await sensor.new_sensor(config[CONF_TOTAL_ENERGY_PRODUCTION])
+        cg.add(var.set_total_energy_production_sensor(sens))
+
+    if CONF_TOTAL_GENERATION_TIME in config:
+        sens = await sensor.new_sensor(config[CONF_TOTAL_GENERATION_TIME])
+        cg.add(var.set_total_generation_time_sensor(sens))
+
+    if CONF_TODAY_GENERATION_TIME in config:
+        sens = await sensor.new_sensor(config[CONF_TODAY_GENERATION_TIME])
+        cg.add(var.set_today_generation_time_sensor(sens))
+
+    if CONF_INVERTER_MODULE_TEMP in config:
+        sens = await sensor.new_sensor(config[CONF_INVERTER_MODULE_TEMP])
+        cg.add(var.set_inverter_module_temp_sensor(sens))
+
+    if CONF_INVERTER_INNER_TEMP in config:
+        sens = await sensor.new_sensor(config[CONF_INVERTER_INNER_TEMP])
+        cg.add(var.set_inverter_inner_temp_sensor(sens))
+
+    if CONF_INVERTER_BUS_VOLTAGE in config:
+        sens = await sensor.new_sensor(config[CONF_INVERTER_BUS_VOLTAGE])
+        cg.add(var.set_inverter_bus_voltage_sensor(sens))
+
+    if CONF_INSULATION_OF_PV_N_TO_GROUND in config:
+        sens = await sensor.new_sensor(config[CONF_INSULATION_OF_PV_N_TO_GROUND])
+        cg.add(var.set_insulation_pv_n_to_ground_sensor(sens))
+
+    if CONF_GFCI_VALUE in config:
+        sens = await sensor.new_sensor(config[CONF_GFCI_VALUE])
+        cg.add(var.set_gfci_value_sensor(sens))
+
+    if CONF_DCI_OF_R in config:
+        sens = await sensor.new_sensor(config[CONF_DCI_OF_R])
+        cg.add(var.set_dci_of_r_sensor(sens))
+
+    if CONF_DCI_OF_S in config:
+        sens = await sensor.new_sensor(config[CONF_DCI_OF_S])
+        cg.add(var.set_dci_of_s_sensor(sens))
+
+    if CONF_DCI_OF_T in config:
+        sens = await sensor.new_sensor(config[CONF_DCI_OF_T])
+        cg.add(var.set_dci_of_t_sensor(sens))
+
+    for i, phase in enumerate([CONF_PHASE_A, CONF_PHASE_B, CONF_PHASE_C]):
+        if phase not in config:
+            continue
+
+        phase_config = config[phase]
+        for sensor_type in PHASE_SENSORS:
+            if sensor_type in phase_config:
+                sens = await sensor.new_sensor(phase_config[sensor_type])
+                cg.add(getattr(var, f"set_{sensor_type}_sensor")(i, sens))
+
+    for i, pv in enumerate([CONF_PV1, CONF_PV2]):
+        if pv not in config:
+            continue
+
+        pv_config = config[pv]
+        for sensor_type in pv_config:
+            if sensor_type in pv_config:
+                sens = await sensor.new_sensor(pv_config[sensor_type])
+                cg.add(getattr(var, f"set_{sensor_type}_sensor_pv")(i, sens))

esphome/components/hdc1080/hdc1080.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace hdc1080 {
 
-static const char *TAG = "hdc1080";
+static const char *const TAG = "hdc1080";
 
 static const uint8_t HDC1080_ADDRESS = 0x40;  // 0b1000000 from datasheet
 static const uint8_t HDC1080_CMD_CONFIGURATION = 0x02;

esphome/components/hitachi_ac344/hitachi_ac344.cpp

@@ -3,7 +3,7 @@
 namespace esphome {
 namespace hitachi_ac344 {
 
-static const char *TAG = "climate.hitachi_ac344";
+static const char *const TAG = "climate.hitachi_ac344";
 
 void set_bits(uint8_t *const dst, const uint8_t offset, const uint8_t nbits, const uint8_t data) {
   if (offset >= 8 || !nbits)

esphome/components/hitachi_ac344/hitachi_ac344.h

@@ -73,17 +73,16 @@ const uint8_t HITACHI_AC344_MILDEWPROOF_OFFSET = 2;  // Mask 0b00000x00
 const uint16_t HITACHI_AC344_STATE_LENGTH = 43;
 const uint16_t HITACHI_AC344_BITS = HITACHI_AC344_STATE_LENGTH * 8;
 
-#define GETBIT8(a, b) (a & ((uint8_t) 1 << b))
+#define GETBIT8(a, b) ((a) & ((uint8_t) 1 << (b)))
 #define GETBITS8(data, offset, size) (((data) & (((uint8_t) UINT8_MAX >> (8 - (size))) << (offset))) >> (offset))
 
 class HitachiClimate : public climate_ir::ClimateIR {
  public:
   HitachiClimate()
-      : climate_ir::ClimateIR(
-            HITACHI_AC344_TEMP_MIN, HITACHI_AC344_TEMP_MAX, 1.0F, true, true,
-            std::vector<climate::ClimateFanMode>{climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW,
-                                                 climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH},
-            std::vector<climate::ClimateSwingMode>{climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL}) {}
+      : climate_ir::ClimateIR(HITACHI_AC344_TEMP_MIN, HITACHI_AC344_TEMP_MAX, 1.0F, true, true,
+                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
+                               climate::CLIMATE_FAN_HIGH},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL}) {}
 
  protected:
   uint8_t remote_state_[HITACHI_AC344_STATE_LENGTH]{0x01, 0x10, 0x00, 0x40, 0x00, 0xFF, 0x00, 0xCC, 0x00, 0x00, 0x00,

esphome/components/hlw8012/hlw8012.cpp

@@ -4,17 +4,34 @@
 namespace esphome {
 namespace hlw8012 {
 
-static const char *TAG = "hlw8012";
+static const char *const TAG = "hlw8012";
 
+// valid for HLW8012 and CSE7759
 static const uint32_t HLW8012_CLOCK_FREQUENCY = 3579000;
-static const float HLW8012_REFERENCE_VOLTAGE = 2.43f;
 
 void HLW8012Component::setup() {
+  float reference_voltage = 0;
   ESP_LOGCONFIG(TAG, "Setting up HLW8012...");
   this->sel_pin_->setup();
   this->sel_pin_->digital_write(this->current_mode_);
   this->cf_store_.pulse_counter_setup(this->cf_pin_);
   this->cf1_store_.pulse_counter_setup(this->cf1_pin_);
+
+  // Initialize multipliers
+  if (this->sensor_model_ == HLW8012_SENSOR_MODEL_BL0937) {
+    reference_voltage = 1.218f;
+    this->power_multiplier_ =
+        reference_voltage * reference_voltage * this->voltage_divider_ / this->current_resistor_ / 1721506.0f;
+    this->current_multiplier_ = reference_voltage / this->current_resistor_ / 94638.0f;
+    this->voltage_multiplier_ = reference_voltage * this->voltage_divider_ / 15397.0f;
+  } else {
+    // HLW8012 and CSE7759 have same reference specs
+    reference_voltage = 2.43f;
+    this->power_multiplier_ = reference_voltage * reference_voltage * this->voltage_divider_ / this->current_resistor_ *
+                              64.0f / 24.0f / HLW8012_CLOCK_FREQUENCY;
+    this->current_multiplier_ = reference_voltage / this->current_resistor_ * 512.0f / 24.0f / HLW8012_CLOCK_FREQUENCY;
+    this->voltage_multiplier_ = reference_voltage * this->voltage_divider_ * 256.0f / HLW8012_CLOCK_FREQUENCY;
+  }
 }
 void HLW8012Component::dump_config() {
   ESP_LOGCONFIG(TAG, "HLW8012:");
@@ -28,6 +45,7 @@ void HLW8012Component::dump_config() {
   LOG_SENSOR("  ", "Voltage", this->voltage_sensor_)
   LOG_SENSOR("  ", "Current", this->current_sensor_)
   LOG_SENSOR("  ", "Power", this->power_sensor_)
+  LOG_SENSOR("  ", "Energy", this->energy_sensor_)
 }
 float HLW8012Component::get_setup_priority() const { return setup_priority::DATA; }
 void HLW8012Component::update() {
@@ -49,25 +67,18 @@ void HLW8012Component::update() {
     return;
   }
 
-  const float v_ref_squared = HLW8012_REFERENCE_VOLTAGE * HLW8012_REFERENCE_VOLTAGE;
-  const float power_multiplier_micros =
-      64000000.0f * v_ref_squared * this->voltage_divider_ / this->current_resistor_ / 24.0f / HLW8012_CLOCK_FREQUENCY;
-  float power = cf_hz * power_multiplier_micros / 1000000.0f;
+  float power = cf_hz * this->power_multiplier_;
 
   if (this->change_mode_at_ != 0) {
     // Only read cf1 after one cycle. Apparently it's quite unstable after being changed.
     if (this->current_mode_) {
-      const float current_multiplier_micros =
-          512000000.0f * HLW8012_REFERENCE_VOLTAGE / this->current_resistor_ / 24.0f / HLW8012_CLOCK_FREQUENCY;
-      float current = cf1_hz * current_multiplier_micros / 1000000.0f;
+      float current = cf1_hz * this->current_multiplier_;
       ESP_LOGD(TAG, "Got power=%.1fW, current=%.1fA", power, current);
       if (this->current_sensor_ != nullptr) {
         this->current_sensor_->publish_state(current);
       }
     } else {
-      const float voltage_multiplier_micros =
-          256000000.0f * HLW8012_REFERENCE_VOLTAGE * this->voltage_divider_ / HLW8012_CLOCK_FREQUENCY;
-      float voltage = cf1_hz * voltage_multiplier_micros / 1000000.0f;
+      float voltage = cf1_hz * this->voltage_multiplier_;
       ESP_LOGD(TAG, "Got power=%.1fW, voltage=%.1fV", power, voltage);
       if (this->voltage_sensor_ != nullptr) {
         this->voltage_sensor_->publish_state(voltage);
@@ -81,7 +92,7 @@ void HLW8012Component::update() {
 
   if (this->energy_sensor_ != nullptr) {
     cf_total_pulses_ += raw_cf;
-    float energy = cf_total_pulses_ * power_multiplier_micros / 3600 / 1000000.0f;
+    float energy = cf_total_pulses_ * this->power_multiplier_ / 3600;
     this->energy_sensor_->publish_state(energy);
   }
 

esphome/components/hlw8012/hlw8012.h

@@ -10,6 +10,12 @@ namespace hlw8012 {
 
 enum HLW8012InitialMode { HLW8012_INITIAL_MODE_CURRENT = 0, HLW8012_INITIAL_MODE_VOLTAGE };
 
+enum HLW8012SensorModels {
+  HLW8012_SENSOR_MODEL_HLW8012 = 0,
+  HLW8012_SENSOR_MODEL_CSE7759,
+  HLW8012_SENSOR_MODEL_BL0937
+};
+
 class HLW8012Component : public PollingComponent {
  public:
   void setup() override;
@@ -20,6 +26,7 @@ class HLW8012Component : public PollingComponent {
   void set_initial_mode(HLW8012InitialMode initial_mode) {
     current_mode_ = initial_mode == HLW8012_INITIAL_MODE_CURRENT;
   }
+  void set_sensor_model(HLW8012SensorModels sensor_model) { sensor_model_ = sensor_model; }
   void set_change_mode_every(uint32_t change_mode_every) { change_mode_every_ = change_mode_every; }
   void set_current_resistor(float current_resistor) { current_resistor_ = current_resistor; }
   void set_voltage_divider(float voltage_divider) { voltage_divider_ = voltage_divider; }
@@ -38,6 +45,7 @@ class HLW8012Component : public PollingComponent {
   uint32_t change_mode_every_{8};
   float current_resistor_{0.001};
   float voltage_divider_{2351};
+  HLW8012SensorModels sensor_model_{HLW8012_SENSOR_MODEL_HLW8012};
   uint64_t cf_total_pulses_{0};
   GPIOPin *sel_pin_;
   GPIOPin *cf_pin_;
@@ -48,6 +56,10 @@ class HLW8012Component : public PollingComponent {
   sensor::Sensor *current_sensor_{nullptr};
   sensor::Sensor *power_sensor_{nullptr};
   sensor::Sensor *energy_sensor_{nullptr};
+
+  float voltage_multiplier_{0.0f};
+  float current_multiplier_{0.0f};
+  float power_multiplier_{0.0f};
 };
 
 }  // namespace hlw8012

esphome/components/hlw8012/sensor.py

@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_POWER,
     CONF_ENERGY,
     CONF_SEL_PIN,
+    CONF_MODEL,
     CONF_VOLTAGE,
     CONF_VOLTAGE_DIVIDER,
     DEVICE_CLASS_CURRENT,
@@ -18,8 +19,8 @@ from esphome.const import (
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_VOLTAGE,
     ICON_EMPTY,
+    LAST_RESET_TYPE_AUTO,
     STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_NONE,
     UNIT_VOLT,
     UNIT_AMPERE,
     UNIT_WATT,
@@ -31,11 +32,19 @@ AUTO_LOAD = ["pulse_counter"]
 hlw8012_ns = cg.esphome_ns.namespace("hlw8012")
 HLW8012Component = hlw8012_ns.class_("HLW8012Component", cg.PollingComponent)
 HLW8012InitialMode = hlw8012_ns.enum("HLW8012InitialMode")
+HLW8012SensorModels = hlw8012_ns.enum("HLW8012SensorModels")
+
 INITIAL_MODES = {
     CONF_CURRENT: HLW8012InitialMode.HLW8012_INITIAL_MODE_CURRENT,
     CONF_VOLTAGE: HLW8012InitialMode.HLW8012_INITIAL_MODE_VOLTAGE,
 }
 
+MODELS = {
+    "HLW8012": HLW8012SensorModels.HLW8012_SENSOR_MODEL_HLW8012,
+    "CSE7759": HLW8012SensorModels.HLW8012_SENSOR_MODEL_CSE7759,
+    "BL0937": HLW8012SensorModels.HLW8012_SENSOR_MODEL_BL0937,
+}
+
 CONF_CF1_PIN = "cf1_pin"
 CONF_CF_PIN = "cf_pin"
 CONFIG_SCHEMA = cv.Schema(
@@ -58,10 +67,16 @@ CONFIG_SCHEMA = cv.Schema(
             UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER, STATE_CLASS_MEASUREMENT
         ),
         cv.Optional(CONF_ENERGY): sensor.sensor_schema(
-            UNIT_WATT_HOURS, ICON_EMPTY, 1, DEVICE_CLASS_ENERGY, STATE_CLASS_NONE
+            UNIT_WATT_HOURS,
+            ICON_EMPTY,
+            1,
+            DEVICE_CLASS_ENERGY,
+            STATE_CLASS_MEASUREMENT,
+            LAST_RESET_TYPE_AUTO,
         ),
         cv.Optional(CONF_CURRENT_RESISTOR, default=0.001): cv.resistance,
         cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351): cv.positive_float,
+        cv.Optional(CONF_MODEL, default="HLW8012"): cv.enum(MODELS, upper=True),
         cv.Optional(CONF_CHANGE_MODE_EVERY, default=8): cv.All(
             cv.uint32_t, cv.Range(min=1)
         ),
@@ -99,3 +114,4 @@ async def to_code(config):
     cg.add(var.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
     cg.add(var.set_change_mode_every(config[CONF_CHANGE_MODE_EVERY]))
     cg.add(var.set_initial_mode(INITIAL_MODES[config[CONF_INITIAL_MODE]]))
+    cg.add(var.set_sensor_model(config[CONF_MODEL]))

esphome/components/hm3301/abstract_aqi_calculator.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include "Arduino.h"
-
 namespace esphome {
 namespace hm3301 {
 

esphome/components/hm3301/aqi_calculator.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "abstract_aqi_calculator.h"
 
 namespace esphome {

esphome/components/hm3301/aqi_calculator_factory.h

@@ -1,8 +1,7 @@
 #pragma once
 
-#include "Arduino.h"
-#include "caqi_calculator.cpp"
-#include "aqi_calculator.cpp"
+#include "caqi_calculator.h"
+#include "aqi_calculator.h"
 
 namespace esphome {
 namespace hm3301 {

esphome/components/hm3301/caqi_calculator.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "esphome/core/log.h"
 #include "abstract_aqi_calculator.h"
 

esphome/components/hm3301/hm3301.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace hm3301 {
 
-static const char *TAG = "hm3301.sensor";
+static const char *const TAG = "hm3301.sensor";
 
 static const uint8_t PM_1_0_VALUE_INDEX = 5;
 static const uint8_t PM_2_5_VALUE_INDEX = 6;

esphome/components/hmc5883l/hmc5883l.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace hmc5883l {
 
-static const char *TAG = "hmc5883l";
+static const char *const TAG = "hmc5883l";
 static const uint8_t HMC5883L_ADDRESS = 0x1E;
 static const uint8_t HMC5883L_REGISTER_CONFIG_A = 0x00;
 static const uint8_t HMC5883L_REGISTER_CONFIG_B = 0x01;

esphome/components/homeassistant/binary_sensor/homeassistant_binary_sensor.cpp

@@ -5,33 +5,34 @@
 namespace esphome {
 namespace homeassistant {
 
-static const char *TAG = "homeassistant.binary_sensor";
+static const char *const TAG = "homeassistant.binary_sensor";
 
 void HomeassistantBinarySensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](std::string state) {
-    auto val = parse_on_off(state.c_str());
-    switch (val) {
-      case PARSE_NONE:
-      case PARSE_TOGGLE:
-        ESP_LOGW(TAG, "Can't convert '%s' to binary state!", state.c_str());
-        break;
-      case PARSE_ON:
-      case PARSE_OFF:
-        bool new_state = val == PARSE_ON;
-        if (this->attribute_.has_value()) {
-          ESP_LOGD(TAG, "'%s::%s': Got attribute state %s", this->entity_id_.c_str(), this->attribute_.value().c_str(),
-                   ONOFF(new_state));
-        } else {
-          ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_.c_str(), ONOFF(new_state));
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        auto val = parse_on_off(state.c_str());
+        switch (val) {
+          case PARSE_NONE:
+          case PARSE_TOGGLE:
+            ESP_LOGW(TAG, "Can't convert '%s' to binary state!", state.c_str());
+            break;
+          case PARSE_ON:
+          case PARSE_OFF:
+            bool new_state = val == PARSE_ON;
+            if (this->attribute_.has_value()) {
+              ESP_LOGD(TAG, "'%s::%s': Got attribute state %s", this->entity_id_.c_str(),
+                       this->attribute_.value().c_str(), ONOFF(new_state));
+            } else {
+              ESP_LOGD(TAG, "'%s': Got state %s", this->entity_id_.c_str(), ONOFF(new_state));
+            }
+            if (this->initial_)
+              this->publish_initial_state(new_state);
+            else
+              this->publish_state(new_state);
+            break;
         }
-        if (this->initial_)
-          this->publish_initial_state(new_state);
-        else
-          this->publish_state(new_state);
-        break;
-    }
-    this->initial_ = false;
-  });
+        this->initial_ = false;
+      });
 }
 void HomeassistantBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "Homeassistant Binary Sensor", this);

esphome/components/homeassistant/sensor/homeassistant_sensor.cpp

@@ -5,25 +5,26 @@
 namespace esphome {
 namespace homeassistant {
 
-static const char *TAG = "homeassistant.sensor";
+static const char *const TAG = "homeassistant.sensor";
 
 void HomeassistantSensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](std::string state) {
-    auto val = parse_float(state);
-    if (!val.has_value()) {
-      ESP_LOGW(TAG, "Can't convert '%s' to number!", state.c_str());
-      this->publish_state(NAN);
-      return;
-    }
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        auto val = parse_float(state);
+        if (!val.has_value()) {
+          ESP_LOGW(TAG, "Can't convert '%s' to number!", state.c_str());
+          this->publish_state(NAN);
+          return;
+        }
 
-    if (this->attribute_.has_value()) {
-      ESP_LOGD(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_.c_str(), this->attribute_.value().c_str(),
-               *val);
-    } else {
-      ESP_LOGD(TAG, "'%s': Got state %.2f", this->entity_id_.c_str(), *val);
-    }
-    this->publish_state(*val);
-  });
+        if (this->attribute_.has_value()) {
+          ESP_LOGD(TAG, "'%s::%s': Got attribute state %.2f", this->entity_id_.c_str(),
+                   this->attribute_.value().c_str(), *val);
+        } else {
+          ESP_LOGD(TAG, "'%s': Got state %.2f", this->entity_id_.c_str(), *val);
+        }
+        this->publish_state(*val);
+      });
 }
 void HomeassistantSensor::dump_config() {
   LOG_SENSOR("", "Homeassistant Sensor", this);

esphome/components/homeassistant/text_sensor/homeassistant_text_sensor.cpp

@@ -5,18 +5,19 @@
 namespace esphome {
 namespace homeassistant {
 
-static const char *TAG = "homeassistant.text_sensor";
+static const char *const TAG = "homeassistant.text_sensor";
 
 void HomeassistantTextSensor::setup() {
-  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, this->attribute_, [this](std::string state) {
-    if (this->attribute_.has_value()) {
-      ESP_LOGD(TAG, "'%s::%s': Got attribute state '%s'", this->entity_id_.c_str(), this->attribute_.value().c_str(),
-               state.c_str());
-    } else {
-      ESP_LOGD(TAG, "'%s': Got state '%s'", this->entity_id_.c_str(), state.c_str());
-    }
-    this->publish_state(state);
-  });
+  api::global_api_server->subscribe_home_assistant_state(
+      this->entity_id_, this->attribute_, [this](const std::string &state) {
+        if (this->attribute_.has_value()) {
+          ESP_LOGD(TAG, "'%s::%s': Got attribute state '%s'", this->entity_id_.c_str(),
+                   this->attribute_.value().c_str(), state.c_str());
+        } else {
+          ESP_LOGD(TAG, "'%s': Got state '%s'", this->entity_id_.c_str(), state.c_str());
+        }
+        this->publish_state(state);
+      });
 }
 void HomeassistantTextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "Homeassistant Text Sensor", this);

esphome/components/homeassistant/time/homeassistant_time.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace homeassistant {
 
-static const char *TAG = "homeassistant.time";
+static const char *const TAG = "homeassistant.time";
 
 void HomeassistantTime::dump_config() {
   ESP_LOGCONFIG(TAG, "Home Assistant Time:");
@@ -17,6 +17,6 @@ void HomeassistantTime::setup() { global_homeassistant_time = this; }
 
 void HomeassistantTime::update() { api::global_api_server->request_time(); }
 
-HomeassistantTime *global_homeassistant_time = nullptr;
+HomeassistantTime *global_homeassistant_time = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 }  // namespace homeassistant
 }  // namespace esphome

esphome/components/homeassistant/time/homeassistant_time.h

@@ -16,7 +16,7 @@ class HomeassistantTime : public time::RealTimeClock {
   float get_setup_priority() const override;
 };
 
-extern HomeassistantTime *global_homeassistant_time;
+extern HomeassistantTime *global_homeassistant_time;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace homeassistant
 }  // namespace esphome

esphome/components/http_request/__init__.py

@@ -7,10 +7,7 @@ from esphome import automation
 from esphome.const import (
     CONF_ID,
     CONF_TIMEOUT,
-    CONF_ESPHOME,
     CONF_METHOD,
-    CONF_ARDUINO_VERSION,
-    ARDUINO_VERSION_ESP8266,
     CONF_TRIGGER_ID,
     CONF_URL,
 )
@@ -78,23 +75,19 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-def validate_framework(config):
-    if CORE.is_esp32:
+def validate_framework(value):
+    if not CORE.is_esp8266:
+        # only for ESP8266
         return
 
-    # only for ESP8266
-    path = [CONF_ESPHOME, CONF_ARDUINO_VERSION]
-    version: str = fv.full_config.get().get_config_for_path(path)
-
-    reverse_map = {v: k for k, v in ARDUINO_VERSION_ESP8266.items()}
-    framework_version = reverse_map.get(version)
+    framework_version = fv.get_arduino_framework_version()
     if framework_version is None or framework_version == "dev":
         return
 
     if framework_version < "2.5.1":
         raise cv.Invalid(
-            "This component is not supported on arduino framework version below 2.5.1",
-            path=[cv.ROOT_CONFIG_PATH] + path,
+            "This component is not supported on arduino framework version below 2.5.1, ",
+            "please check esphome->arduino_version",
         )
 
 

esphome/components/http_request/http_request.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace http_request {
 
-static const char *TAG = "http_request";
+static const char *const TAG = "http_request";
 
 void HttpRequestComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "HTTP Request:");
@@ -13,8 +13,8 @@ void HttpRequestComponent::dump_config() {
 }
 
 void HttpRequestComponent::set_url(std::string url) {
-  this->url_ = url;
-  this->secure_ = url.compare(0, 6, "https:") == 0;
+  this->url_ = std::move(url);
+  this->secure_ = this->url_.compare(0, 6, "https:") == 0;
 
   if (!this->last_url_.empty() && this->url_ != this->last_url_) {
     // Close connection if url has been changed

esphome/components/http_request/http_request.h

@@ -1,10 +1,11 @@
 #pragma once
 
+#include "esphome/components/json/json_util.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
 #include <list>
 #include <map>
-#include "esphome/core/component.h"
-#include "esphome/core/automation.h"
-#include "esphome/components/json/json_util.h"
+#include <utility>
 
 #ifdef ARDUINO_ARCH_ESP32
 #include <HTTPClient.h>
@@ -33,8 +34,8 @@ class HttpRequestComponent : public Component {
   void set_method(const char *method) { this->method_ = method; }
   void set_useragent(const char *useragent) { this->useragent_ = useragent; }
   void set_timeout(uint16_t timeout) { this->timeout_ = timeout; }
-  void set_body(std::string body) { this->body_ = body; }
-  void set_headers(std::list<Header> headers) { this->headers_ = headers; }
+  void set_body(std::string body) { this->body_ = std::move(body); }
+  void set_headers(std::list<Header> headers) { this->headers_ = std::move(headers); }
   void send(const std::vector<HttpRequestResponseTrigger *> &response_triggers);
   void close();
   const char *get_string();

esphome/components/htu21d/htu21d.cpp

@@ -4,7 +4,7 @@
 namespace esphome {
 namespace htu21d {
 
-static const char *TAG = "htu21d";
+static const char *const TAG = "htu21d";
 
 static const uint8_t HTU21D_ADDRESS = 0x40;
 static const uint8_t HTU21D_REGISTER_RESET = 0xFE;

esphome/components/hx711/hx711.cpp

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace hx711 {
 
-static const char *TAG = "hx711";
+static const char *const TAG = "hx711";
 
 void HX711Sensor::setup() {
   ESP_LOGCONFIG(TAG, "Setting up HX711 '%s'...", this->name_.c_str());

esphome/components/i2c/i2c.cpp

@@ -6,7 +6,7 @@
 namespace esphome {
 namespace i2c {
 
-static const char *TAG = "i2c";
+static const char *const TAG = "i2c";
 
 I2CComponent::I2CComponent() {
 #ifdef ARDUINO_ARCH_ESP32