Merge remote-tracking branch 'upstream/dev' into dev

.github/workflows/ci.yml

@@ -20,7 +20,6 @@ permissions:
 env:
   DEFAULT_PYTHON: "3.9"
   PYUPGRADE_TARGET: "--py39-plus"
-  CLANG_FORMAT_VERSION: "13.0.1"
 
 concurrency:
   # yamllint disable-line rule:line-length
@@ -239,7 +238,7 @@ jobs:
       - name: Install clang-format
         run: |
           . venv/bin/activate
-          pip install clang-format==${{ env.CLANG_FORMAT_VERSION }}
+          pip install clang-format -c requirements_dev.txt
       - name: Run clang-format
         run: |
           . venv/bin/activate
@@ -399,7 +398,8 @@ jobs:
       - common
     if: github.event_name == 'pull_request'
     outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
+      components: ${{ steps.list-components.outputs.components }}
+      count: ${{ steps.list-components.outputs.count }}
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@v4.1.1
@@ -420,10 +420,18 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
       - name: Find changed components
-        id: set-matrix
+        id: list-components
         run: |
           . venv/bin/activate
-          echo "matrix=$(script/list-components.py --changed --branch ${{ steps.target-branch.outputs.branch }} | jq -R -s -c 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          components=$(script/list-components.py --changed --branch ${{ steps.target-branch.outputs.branch }})
+          output_components=$(echo "$components" | jq -R -s -c 'split("\n")[:-1] | map(select(length > 0))')
+          count=$(echo "$output_components" | jq length)
+
+          echo "components=$output_components" >> $GITHUB_OUTPUT
+          echo "count=$count" >> $GITHUB_OUTPUT
+
+          echo "$count Components:"
+          echo "$output_components" | jq
 
   test-build-components:
     name: Component test ${{ matrix.file }}
@@ -431,12 +439,12 @@ jobs:
     needs:
       - common
       - list-components
-    if: ${{ github.event_name == 'pull_request' && needs.list-components.outputs.matrix != '[]' && needs.list-components.outputs.matrix != '' }}
+    if: github.event_name == 'pull_request' && fromJSON(needs.list-components.outputs.count) > 0 && fromJSON(needs.list-components.outputs.count) < 100
     strategy:
       fail-fast: false
       max-parallel: 2
       matrix:
-        file: ${{ fromJson(needs.list-components.outputs.matrix) }}
+        file: ${{ fromJson(needs.list-components.outputs.components) }}
     steps:
       - name: Install libsodium
         run: sudo apt-get install libsodium-dev
@@ -457,6 +465,64 @@ jobs:
           . venv/bin/activate
           ./script/test_build_components -e compile -c ${{ matrix.file }}
 
+  test-build-components-splitter:
+    name: Split components for testing into 20 groups maximum
+    runs-on: ubuntu-latest
+    needs:
+      - common
+      - list-components
+    if: github.event_name == 'pull_request' && fromJSON(needs.list-components.outputs.count) >= 100
+    outputs:
+      matrix: ${{ steps.split.outputs.components }}
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Split components into 20 groups
+        id: split
+        run: |
+          components=$(echo '${{ needs.list-components.outputs.components }}' | jq -c '.[]' | shuf | jq -s -c '[_nwise(20) | join(" ")]')
+          echo "components=$components" >> $GITHUB_OUTPUT
+
+  test-build-components-split:
+    name: Test split components
+    runs-on: ubuntu-latest
+    needs:
+      - common
+      - list-components
+      - test-build-components-splitter
+    if: github.event_name == 'pull_request' && fromJSON(needs.list-components.outputs.count) >= 100
+    strategy:
+      fail-fast: false
+      max-parallel: 4
+      matrix:
+        components: ${{ fromJson(needs.test-build-components-splitter.outputs.matrix) }}
+    steps:
+      - name: List components
+        run: echo ${{ matrix.components }}
+
+      - name: Install libsodium
+        run: sudo apt-get install libsodium-dev
+
+      - name: Check out code from GitHub
+        uses: actions/checkout@v4.1.1
+      - name: Restore Python
+        uses: ./.github/actions/restore-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          cache-key: ${{ needs.common.outputs.cache-key }}
+      - name: Validate config
+        run: |
+          . venv/bin/activate
+          for component in ${{ matrix.components }}; do
+            ./script/test_build_components -e config -c $component
+          done
+      - name: Compile config
+        run: |
+          . venv/bin/activate
+          for component in ${{ matrix.components }}; do
+            ./script/test_build_components -e compile -c $component
+          done
+
   ci-status:
     name: CI Status
     runs-on: ubuntu-latest
@@ -471,7 +537,10 @@ jobs:
       - pyupgrade
       - compile-tests
       - clang-tidy
+      - list-components
       - test-build-components
+      - test-build-components-splitter
+      - test-build-components-split
     if: always()
     steps:
       - name: Success
@@ -479,4 +548,8 @@ jobs:
         run: exit 0
       - name: Failure
         if: ${{ contains(needs.*.result, 'failure') }}
-        run: exit 1
+        env:
+          JSON_DOC: ${{ toJSON(needs) }}
+        run: |
+          echo $JSON_DOC | jq
+          exit 1

.github/workflows/release.yml

@@ -17,14 +17,16 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       tag: ${{ steps.tag.outputs.tag }}
+      branch_build: ${{ steps.tag.outputs.branch_build }}
     steps:
       - uses: actions/checkout@v4.1.1
       - name: Get tag
         id: tag
         # yamllint disable rule:line-length
         run: |
-          if [[ "$GITHUB_EVENT_NAME" = "release" ]]; then
+          if [[ "${{ github.event_name }}" = "release" ]]; then
-            TAG="${GITHUB_REF#refs/tags/}"
+            TAG="${{ github.event.release.tag_name}}"
+            BRANCH_BUILD="false"
           else
             TAG=$(cat esphome/const.py | sed -n -E "s/^__version__\s+=\s+\"(.+)\"$/\1/p")
             today="$(date --utc '+%Y%m%d')"
@@ -32,15 +34,22 @@ jobs:
             BRANCH=${GITHUB_REF#refs/heads/}
             if [[ "$BRANCH" != "dev" ]]; then
               TAG="${TAG}-${BRANCH}"
+              BRANCH_BUILD="true"
+            else
+              BRANCH_BUILD="false"
             fi
           fi
           echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          echo "branch_build=${BRANCH_BUILD}" >> $GITHUB_OUTPUT
         # yamllint enable rule:line-length
 
   deploy-pypi:
     name: Build and publish to PyPi
     if: github.repository == 'esphome/esphome' && github.event_name == 'release'
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
     steps:
       - uses: actions/checkout@v4.1.1
       - name: Set up Python
@@ -50,16 +59,11 @@ jobs:
       - name: Set up python environment
         env:
           ESPHOME_NO_VENV: 1
-        run: |
+        run: script/setup
-          script/setup
-          pip install twine
       - name: Build
         run: python setup.py sdist bdist_wheel
-      - name: Upload
+      - name: Publish
-        env:
+        uses: pypa/gh-action-pypi-publish@v1.8.14
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-        run: twine upload dist/*
 
   deploy-docker:
     name: Build ESPHome ${{ matrix.platform }}
@@ -197,22 +201,28 @@ jobs:
             $(printf '${{ steps.tags.outputs.image }}@sha256:%s ' *)
 
   deploy-ha-addon-repo:
-    if: github.repository == 'esphome/esphome' && github.event_name == 'release'
+    if: github.repository == 'esphome/esphome' && needs.init.outputs.branch_build == 'false'
     runs-on: ubuntu-latest
-    needs: [deploy-manifest]
+    needs:
+      - init
+      - deploy-manifest
     steps:
       - name: Trigger Workflow
         uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ secrets.DEPLOY_HA_ADDON_REPO_TOKEN }}
           script: |
+            let description = "ESPHome";
+            if (context.eventName == "release") {
+              description = ${{ toJSON(github.event.release.body) }};
+            }
             github.rest.actions.createWorkflowDispatch({
               owner: "esphome",
               repo: "home-assistant-addon",
               workflow_id: "bump-version.yml",
               ref: "main",
               inputs: {
-                version: "${{ github.event.release.tag_name }}",
+                version: "${{ needs.init.outputs.tag }}",
-                content: ${{ toJSON(github.event.release.body) }}
+                content: description
               }
             })

.github/workflows/sync-device-classes.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v5.1.0
         with:
-          python-version: 3.11
+          python-version: 3.12
 
       - name: Install Home Assistant
         run: |
@@ -36,7 +36,7 @@ jobs:
           python ./script/sync-device_class.py
 
       - name: Commit changes
-        uses: peter-evans/create-pull-request@v6.0.2
+        uses: peter-evans/create-pull-request@v6.0.4
         with:
           commit-message: "Synchronise Device Classes from Home Assistant"
           committer: esphomebot <esphome@nabucasa.com>

.pre-commit-config.yaml

@@ -27,7 +27,16 @@ repos:
           - --branch=release
           - --branch=beta
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.15.1
+    rev: v3.15.2
     hooks:
       - id: pyupgrade
         args: [--py39-plus]
+  - repo: https://github.com/adrienverge/yamllint.git
+    rev: v1.35.1
+    hooks:
+      - id: yamllint
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v13.0.1
+    hooks:
+      - id: clang-format
+        types_or: [c, c++]

CODEOWNERS

@@ -120,6 +120,7 @@ esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
 esphome/components/ethernet_info/* @gtjadsonsantos
+esphome/components/event/* @nohat
 esphome/components/exposure_notifications/* @OttoWinter
 esphome/components/ezo/* @ssieb
 esphome/components/ezo_pmp/* @carlos-sarmiento
@@ -360,11 +361,13 @@ esphome/components/tee501/* @Stock-M
 esphome/components/teleinfo/* @0hax
 esphome/components/template/alarm_control_panel/* @grahambrown11 @hwstar
 esphome/components/template/datetime/* @rfdarter
+esphome/components/template/event/* @nohat
 esphome/components/template/fan/* @ssieb
 esphome/components/text/* @mauritskorse
 esphome/components/thermostat/* @kbx81
 esphome/components/time/* @OttoWinter
 esphome/components/tlc5947/* @rnauber
+esphome/components/tlc5971/* @IJIJI
 esphome/components/tm1621/* @Philippe12
 esphome/components/tm1637/* @glmnet
 esphome/components/tm1638/* @skykingjwc
@@ -390,6 +393,7 @@ esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
 esphome/components/ultrasonic/* @OttoWinter
 esphome/components/uponor_smatrix/* @kroimon
+esphome/components/valve/* @esphome/core
 esphome/components/vbus/* @ssieb
 esphome/components/veml3235/* @kbx81
 esphome/components/veml7700/* @latonita
@@ -399,10 +403,21 @@ esphome/components/wake_on_lan/* @willwill2will54
 esphome/components/waveshare_epaper/* @clydebarrow
 esphome/components/web_server_base/* @OttoWinter
 esphome/components/web_server_idf/* @dentra
+esphome/components/weikai/* @DrCoolZic
+esphome/components/weikai_i2c/* @DrCoolZic
+esphome/components/weikai_spi/* @DrCoolZic
 esphome/components/whirlpool/* @glmnet
 esphome/components/whynter/* @aeonsablaze
 esphome/components/wiegand/* @ssieb
 esphome/components/wireguard/* @droscy @lhoracek @thomas0bernard
+esphome/components/wk2132_i2c/* @DrCoolZic
+esphome/components/wk2132_spi/* @DrCoolZic
+esphome/components/wk2168_i2c/* @DrCoolZic
+esphome/components/wk2168_spi/* @DrCoolZic
+esphome/components/wk2204_i2c/* @DrCoolZic
+esphome/components/wk2204_spi/* @DrCoolZic
+esphome/components/wk2212_i2c/* @DrCoolZic
+esphome/components/wk2212_spi/* @DrCoolZic
 esphome/components/wl_134/* @hobbypunk90
 esphome/components/x9c/* @EtienneMD
 esphome/components/xgzp68xx/* @gcormier

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

@@ -0,0 +1,47 @@
+#!/usr/bin/with-contenv bashio
+# ==============================================================================
+# This file installs the user ESPHome fork if specified.
+# The fork must be up to date with the latest ESPHome dev branch
+# and have no conflicts.
+# This config option only exists in the ESPHome Dev add-on.
+# ==============================================================================
+
+declare esphome_fork
+
+if bashio::config.has_value 'esphome_fork'; then
+  esphome_fork=$(bashio::config 'esphome_fork')
+  # format: [username][/repository]:ref
+  if [[ "$esphome_fork" =~ ^(([^/]+)(/([^:]+))?:)?([^:/]+)$ ]]; then
+    username="${BASH_REMATCH[2]:-esphome}"
+    repository="${BASH_REMATCH[4]:-esphome}"
+    ref="${BASH_REMATCH[5]}"
+  else
+    bashio::exit.nok "Invalid esphome_fork format: $esphome_fork"
+  fi
+  full_url="https://github.com/${username}/${repository}/archive/${ref}.tar.gz"
+  bashio::log.info "Checking forked ESPHome"
+  dev_version=$(python3 -c "from esphome.const import __version__; print(__version__)")
+  bashio::log.info "Downloading ESPHome from fork '${esphome_fork}' (${full_url})..."
+  curl -L -o /tmp/esphome.tar.gz "${full_url}" -qq ||
+    bashio::exit.nok "Failed downloading ESPHome fork."
+  bashio::log.info "Installing ESPHome from fork '${esphome_fork}' (${full_url})..."
+  rm -rf /esphome || bashio::exit.nok "Failed to remove ESPHome."
+  mkdir /esphome
+  tar -zxf /tmp/esphome.tar.gz -C /esphome --strip-components=1 ||
+    bashio::exit.nok "Failed installing ESPHome from fork."
+  pip install -U -e /esphome || bashio::exit.nok "Failed installing ESPHome from fork."
+  rm -f /tmp/esphome.tar.gz
+  fork_version=$(python3 -c "from esphome.const import __version__; print(__version__)")
+
+  if [[ "$fork_version" != "$dev_version" ]]; then
+    bashio::log.error "############################"
+    bashio::log.error "Uninstalled fork as version does not match"
+    bashio::log.error "Update (or ask the author to update) the branch"
+    bashio::log.error "This is important as the dev addon and the dev ESPHome"
+    bashio::log.error "branch can have changes that are not compatible with old forks"
+    bashio::log.error "and get reported as bugs which we cannot solve easily."
+    bashio::log.error "############################"
+    bashio::exit.nok
+  fi
+  bashio::log.info "Installed ESPHome from fork '${esphome_fork}' (${full_url})..."
+fi

esphome/__main__.py

@@ -785,6 +785,7 @@ def parse_args(argv):
     parser_logs = subparsers.add_parser(
         "logs",
         help="Validate the configuration and show all logs.",
+        aliases=["log"],
         parents=[mqtt_options],
     )
     parser_logs.add_argument(

esphome/components/ads1115/__init__.py

@@ -4,13 +4,14 @@ from esphome.components import i2c
 from esphome.const import CONF_ID
 
 DEPENDENCIES = ["i2c"]
-AUTO_LOAD = ["sensor", "voltage_sampler"]
 MULTI_CONF = True
 
 ads1115_ns = cg.esphome_ns.namespace("ads1115")
 ADS1115Component = ads1115_ns.class_("ADS1115Component", cg.Component, i2c.I2CDevice)
 
 CONF_CONTINUOUS_MODE = "continuous_mode"
+CONF_ADS1115_ID = "ads1115_id"
+
 CONFIG_SCHEMA = (
     cv.Schema(
         {

esphome/components/ads1115/ads1115.cpp

@@ -1,6 +1,6 @@
 #include "ads1115.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ads1115 {
@@ -75,25 +75,19 @@ void ADS1115Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Communication with ADS1115 failed!");
   }
-
-  for (auto *sensor : this->sensors_) {
-    LOG_SENSOR("  ", "Sensor", sensor);
-    ESP_LOGCONFIG(TAG, "    Multiplexer: %u", sensor->get_multiplexer());
-    ESP_LOGCONFIG(TAG, "    Gain: %u", sensor->get_gain());
-    ESP_LOGCONFIG(TAG, "    Resolution: %u", sensor->get_resolution());
-  }
 }
-float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
+float ADS1115Component::request_measurement(ADS1115Multiplexer multiplexer, ADS1115Gain gain,
+                                            ADS1115Resolution resolution) {
   uint16_t config = this->prev_config_;
   // Multiplexer
   //        0bxBBBxxxxxxxxxxxx
   config &= 0b1000111111111111;
-  config |= (sensor->get_multiplexer() & 0b111) << 12;
+  config |= (multiplexer & 0b111) << 12;
 
   // Gain
   //        0bxxxxBBBxxxxxxxxx
   config &= 0b1111000111111111;
-  config |= (sensor->get_gain() & 0b111) << 9;
+  config |= (gain & 0b111) << 9;
 
   if (!this->continuous_mode_) {
     // Start conversion
@@ -132,7 +126,7 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
     return NAN;
   }
 
-  if (sensor->get_resolution() == ADS1015_12_BITS) {
+  if (resolution == ADS1015_12_BITS) {
     bool negative = (raw_conversion >> 15) == 1;
 
     // shift raw_conversion as it's only 12-bits, left justified
@@ -151,8 +145,8 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
   auto signed_conversion = static_cast<int16_t>(raw_conversion);
 
   float millivolts;
-  float divider = (sensor->get_resolution() == ADS1115_16_BITS) ? 32768.0f : 2048.0f;
+  float divider = (resolution == ADS1115_16_BITS) ? 32768.0f : 2048.0f;
-  switch (sensor->get_gain()) {
+  switch (gain) {
     case ADS1115_GAIN_6P144:
       millivolts = (signed_conversion * 6144) / divider;
       break;
@@ -179,14 +173,5 @@ float ADS1115Component::request_measurement(ADS1115Sensor *sensor) {
   return millivolts / 1e3f;
 }
 
-float ADS1115Sensor::sample() { return this->parent_->request_measurement(this); }
-void ADS1115Sensor::update() {
-  float v = this->parent_->request_measurement(this);
-  if (!std::isnan(v)) {
-    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", this->get_name().c_str(), v);
-    this->publish_state(v);
-  }
-}
-
 }  // namespace ads1115
 }  // namespace esphome

esphome/components/ads1115/ads1115.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/components/voltage_sampler/voltage_sampler.h"
+#include "esphome/core/component.h"
 
 #include <vector>
 
@@ -35,12 +33,8 @@ enum ADS1115Resolution {
   ADS1015_12_BITS = 12,
 };
 
-class ADS1115Sensor;
-
 class ADS1115Component : public Component, public i2c::I2CDevice {
  public:
-  void register_sensor(ADS1115Sensor *obj) { this->sensors_.push_back(obj); }
-  /// Set up the internal sensor array.
   void setup() override;
   void dump_config() override;
   /// HARDWARE_LATE setup priority
@@ -48,33 +42,12 @@ class ADS1115Component : public Component, public i2c::I2CDevice {
   void set_continuous_mode(bool continuous_mode) { continuous_mode_ = continuous_mode; }
 
   /// Helper method to request a measurement from a sensor.
-  float request_measurement(ADS1115Sensor *sensor);
+  float request_measurement(ADS1115Multiplexer multiplexer, ADS1115Gain gain, ADS1115Resolution resolution);
 
  protected:
-  std::vector<ADS1115Sensor *> sensors_;
   uint16_t prev_config_{0};
   bool continuous_mode_;
 };
 
-/// Internal holder class that is in instance of Sensor so that the hub can create individual sensors.
-class ADS1115Sensor : public sensor::Sensor, public PollingComponent, public voltage_sampler::VoltageSampler {
- public:
-  ADS1115Sensor(ADS1115Component *parent) : parent_(parent) {}
-  void update() override;
-  void set_multiplexer(ADS1115Multiplexer multiplexer) { multiplexer_ = multiplexer; }
-  void set_gain(ADS1115Gain gain) { gain_ = gain; }
-  void set_resolution(ADS1115Resolution resolution) { resolution_ = resolution; }
-  float sample() override;
-  uint8_t get_multiplexer() const { return multiplexer_; }
-  uint8_t get_gain() const { return gain_; }
-  uint8_t get_resolution() const { return resolution_; }
-
- protected:
-  ADS1115Component *parent_;
-  ADS1115Multiplexer multiplexer_;
-  ADS1115Gain gain_;
-  ADS1115Resolution resolution_;
-};
-
 }  // namespace ads1115
 }  // namespace esphome

esphome/components/ads1115/sensor/__init__.py

@@ -10,8 +10,9 @@ from esphome.const import (
     UNIT_VOLT,
     CONF_ID,
 )
-from . import ads1115_ns, ADS1115Component
+from .. import ads1115_ns, ADS1115Component, CONF_ADS1115_ID
 
+AUTO_LOAD = ["voltage_sampler"]
 DEPENDENCIES = ["ads1115"]
 
 ADS1115Multiplexer = ads1115_ns.enum("ADS1115Multiplexer")
@@ -43,20 +44,10 @@ RESOLUTION = {
 }
 
 
-def validate_gain(value):
-    if isinstance(value, float):
-        value = f"{value:0.03f}"
-    elif not isinstance(value, str):
-        raise cv.Invalid(f'invalid gain "{value}"')
-
-    return cv.enum(GAIN)(value)
-
-
 ADS1115Sensor = ads1115_ns.class_(
     "ADS1115Sensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
 
-CONF_ADS1115_ID = "ads1115_id"
 CONFIG_SCHEMA = (
     sensor.sensor_schema(
         ADS1115Sensor,
@@ -69,7 +60,7 @@ CONFIG_SCHEMA = (
         {
             cv.GenerateID(CONF_ADS1115_ID): cv.use_id(ADS1115Component),
             cv.Required(CONF_MULTIPLEXER): cv.enum(MUX, upper=True, space="_"),
-            cv.Required(CONF_GAIN): validate_gain,
+            cv.Required(CONF_GAIN): cv.enum(GAIN, string=True),
             cv.Optional(CONF_RESOLUTION, default="16_BITS"): cv.enum(
                 RESOLUTION, upper=True, space="_"
             ),
@@ -80,13 +71,11 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
-    paren = await cg.get_variable(config[CONF_ADS1115_ID])
+    var = cg.new_Pvariable(config[CONF_ID])
-    var = cg.new_Pvariable(config[CONF_ID], paren)
     await sensor.register_sensor(var, config)
     await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_ADS1115_ID])
 
     cg.add(var.set_multiplexer(config[CONF_MULTIPLEXER]))
     cg.add(var.set_gain(config[CONF_GAIN]))
     cg.add(var.set_resolution(config[CONF_RESOLUTION]))
-
-    cg.add(paren.register_sensor(var))

esphome/components/ads1115/sensor/ads1115_sensor.cpp

@@ -0,0 +1,30 @@
+#include "ads1115_sensor.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace ads1115 {
+
+static const char *const TAG = "ads1115.sensor";
+
+float ADS1115Sensor::sample() {
+  return this->parent_->request_measurement(this->multiplexer_, this->gain_, this->resolution_);
+}
+
+void ADS1115Sensor::update() {
+  float v = this->sample();
+  if (!std::isnan(v)) {
+    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", this->get_name().c_str(), v);
+    this->publish_state(v);
+  }
+}
+
+void ADS1115Sensor::dump_config() {
+  LOG_SENSOR("  ", "ADS1115 Sensor", this);
+  ESP_LOGCONFIG(TAG, "    Multiplexer: %u", this->multiplexer_);
+  ESP_LOGCONFIG(TAG, "    Gain: %u", this->gain_);
+  ESP_LOGCONFIG(TAG, "    Resolution: %u", this->resolution_);
+}
+
+}  // namespace ads1115
+}  // namespace esphome

esphome/components/ads1115/sensor/ads1115_sensor.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/voltage_sampler/voltage_sampler.h"
+
+#include "../ads1115.h"
+
+namespace esphome {
+namespace ads1115 {
+
+/// Internal holder class that is in instance of Sensor so that the hub can create individual sensors.
+class ADS1115Sensor : public sensor::Sensor,
+                      public PollingComponent,
+                      public voltage_sampler::VoltageSampler,
+                      public Parented<ADS1115Component> {
+ public:
+  void update() override;
+  void set_multiplexer(ADS1115Multiplexer multiplexer) { this->multiplexer_ = multiplexer; }
+  void set_gain(ADS1115Gain gain) { this->gain_ = gain; }
+  void set_resolution(ADS1115Resolution resolution) { this->resolution_ = resolution; }
+  float sample() override;
+
+  void dump_config() override;
+
+ protected:
+  ADS1115Multiplexer multiplexer_;
+  ADS1115Gain gain_;
+  ADS1115Resolution resolution_;
+};
+
+}  // namespace ads1115
+}  // namespace esphome

esphome/components/api/api.proto

@@ -43,6 +43,7 @@ service APIConnection {
   rpc select_command (SelectCommandRequest) returns (void) {}
   rpc button_command (ButtonCommandRequest) returns (void) {}
   rpc lock_command (LockCommandRequest) returns (void) {}
+  rpc valve_command (ValveCommandRequest) returns (void) {}
   rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
   rpc date_command (DateCommandRequest) returns (void) {}
   rpc time_command (TimeCommandRequest) returns (void) {}
@@ -1700,3 +1701,79 @@ message TimeCommandRequest {
   uint32 minute = 3;
   uint32 second = 4;
 }
+
+// ==================== EVENT ====================
+message ListEntitiesEventResponse {
+  option (id) = 107;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_EVENT";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+  string device_class = 8;
+
+  repeated string event_types = 9;
+}
+message EventResponse {
+  option (id) = 108;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_EVENT";
+
+  fixed32 key = 1;
+  string event_type = 2;
+}
+
+// ==================== VALVE ====================
+message ListEntitiesValveResponse {
+  option (id) = 109;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_VALVE";
+
+  string object_id = 1;
+  fixed32 key = 2;
+  string name = 3;
+  string unique_id = 4;
+
+  string icon = 5;
+  bool disabled_by_default = 6;
+  EntityCategory entity_category = 7;
+  string device_class = 8;
+
+  bool assumed_state = 9;
+  bool supports_position = 10;
+  bool supports_stop = 11;
+}
+
+enum ValveOperation {
+  VALVE_OPERATION_IDLE = 0;
+  VALVE_OPERATION_IS_OPENING = 1;
+  VALVE_OPERATION_IS_CLOSING = 2;
+}
+message ValveStateResponse {
+  option (id) = 110;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_VALVE";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  float position = 2;
+  ValveOperation current_operation = 3;
+}
+
+message ValveCommandRequest {
+  option (id) = 111;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_VALVE";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  bool has_position = 2;
+  float position = 3;
+  bool stop = 4;
+}

esphome/components/api/api_connection.cpp

@@ -915,6 +915,48 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_VALVE
+bool APIConnection::send_valve_state(valve::Valve *valve) {
+  if (!this->state_subscription_)
+    return false;
+
+  ValveStateResponse resp{};
+  resp.key = valve->get_object_id_hash();
+  resp.position = valve->position;
+  resp.current_operation = static_cast<enums::ValveOperation>(valve->current_operation);
+  return this->send_valve_state_response(resp);
+}
+bool APIConnection::send_valve_info(valve::Valve *valve) {
+  auto traits = valve->get_traits();
+  ListEntitiesValveResponse msg;
+  msg.key = valve->get_object_id_hash();
+  msg.object_id = valve->get_object_id();
+  if (valve->has_own_name())
+    msg.name = valve->get_name();
+  msg.unique_id = get_default_unique_id("valve", valve);
+  msg.icon = valve->get_icon();
+  msg.disabled_by_default = valve->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(valve->get_entity_category());
+  msg.device_class = valve->get_device_class();
+  msg.assumed_state = traits.get_is_assumed_state();
+  msg.supports_position = traits.get_supports_position();
+  msg.supports_stop = traits.get_supports_stop();
+  return this->send_list_entities_valve_response(msg);
+}
+void APIConnection::valve_command(const ValveCommandRequest &msg) {
+  valve::Valve *valve = App.get_valve_by_key(msg.key);
+  if (valve == nullptr)
+    return;
+
+  auto call = valve->make_call();
+  if (msg.has_position)
+    call.set_position(msg.position);
+  if (msg.stop)
+    call.set_command_stop();
+  call.perform();
+}
+#endif
+
 #ifdef USE_MEDIA_PLAYER
 bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
   if (!this->state_subscription_)
@@ -1167,6 +1209,30 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 }
 #endif
 
+#ifdef USE_EVENT
+bool APIConnection::send_event(event::Event *event, std::string event_type) {
+  EventResponse resp{};
+  resp.key = event->get_object_id_hash();
+  resp.event_type = std::move(event_type);
+  return this->send_event_response(resp);
+}
+bool APIConnection::send_event_info(event::Event *event) {
+  ListEntitiesEventResponse msg;
+  msg.key = event->get_object_id_hash();
+  msg.object_id = event->get_object_id();
+  if (event->has_own_name())
+    msg.name = event->get_name();
+  msg.unique_id = get_default_unique_id("event", event);
+  msg.icon = event->get_icon();
+  msg.disabled_by_default = event->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(event->get_entity_category());
+  msg.device_class = event->get_device_class();
+  for (const auto &event_type : event->get_event_types())
+    msg.event_types.push_back(event_type);
+  return this->send_list_entities_event_response(msg);
+}
+#endif
+
 bool APIConnection::send_log_message(int level, const char *tag, const char *line) {
   if (this->log_subscription_ < level)
     return false;

esphome/components/api/api_connection.h

@@ -101,6 +101,11 @@ class APIConnection : public APIServerConnection {
   bool send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
 #endif
+#ifdef USE_VALVE
+  bool send_valve_state(valve::Valve *valve);
+  bool send_valve_info(valve::Valve *valve);
+  void valve_command(const ValveCommandRequest &msg) override;
+#endif
 #ifdef USE_MEDIA_PLAYER
   bool send_media_player_state(media_player::MediaPlayer *media_player);
   bool send_media_player_info(media_player::MediaPlayer *media_player);
@@ -148,6 +153,11 @@ class APIConnection : public APIServerConnection {
   void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) override;
 #endif
 
+#ifdef USE_EVENT
+  bool send_event(event::Event *event, std::string event_type);
+  bool send_event_info(event::Event *event);
+#endif
+
   void on_disconnect_response(const DisconnectResponse &value) override;
   void on_ping_response(const PingResponse &value) override {
     // we initiated ping

esphome/components/api/api_pb2.cpp

@@ -537,6 +537,20 @@ template<> const char *proto_enum_to_string<enums::TextMode>(enums::TextMode val
   }
 }
 #endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+template<> const char *proto_enum_to_string<enums::ValveOperation>(enums::ValveOperation value) {
+  switch (value) {
+    case enums::VALVE_OPERATION_IDLE:
+      return "VALVE_OPERATION_IDLE";
+    case enums::VALVE_OPERATION_IS_OPENING:
+      return "VALVE_OPERATION_IS_OPENING";
+    case enums::VALVE_OPERATION_IS_CLOSING:
+      return "VALVE_OPERATION_IS_CLOSING";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
 bool HelloRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 2: {
@@ -7695,6 +7709,390 @@ void TimeCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesEventResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesEventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    case 8: {
+      this->device_class = value.as_string();
+      return true;
+    }
+    case 9: {
+      this->event_types.push_back(value.as_string());
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesEventResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesEventResponse::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_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_string(8, this->device_class);
+  for (auto &it : this->event_types) {
+    buffer.encode_string(9, it, true);
+  }
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesEventResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesEventResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, 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("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  device_class: ");
+  out.append("'").append(this->device_class).append("'");
+  out.append("\n");
+
+  for (const auto &it : this->event_types) {
+    out.append("  event_types: ");
+    out.append("'").append(it).append("'");
+    out.append("\n");
+  }
+  out.append("}");
+}
+#endif
+bool EventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 2: {
+      this->event_type = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool EventResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void EventResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_string(2, this->event_type);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void EventResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("EventResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  event_type: ");
+  out.append("'").append(this->event_type).append("'");
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool ListEntitiesValveResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 6: {
+      this->disabled_by_default = value.as_bool();
+      return true;
+    }
+    case 7: {
+      this->entity_category = value.as_enum<enums::EntityCategory>();
+      return true;
+    }
+    case 9: {
+      this->assumed_state = value.as_bool();
+      return true;
+    }
+    case 10: {
+      this->supports_position = value.as_bool();
+      return true;
+    }
+    case 11: {
+      this->supports_stop = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesValveResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    case 8: {
+      this->device_class = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesValveResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesValveResponse::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_bool(6, this->disabled_by_default);
+  buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
+  buffer.encode_string(8, this->device_class);
+  buffer.encode_bool(9, this->assumed_state);
+  buffer.encode_bool(10, this->supports_position);
+  buffer.encode_bool(11, this->supports_stop);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesValveResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesValveResponse {\n");
+  out.append("  object_id: ");
+  out.append("'").append(this->object_id).append("'");
+  out.append("\n");
+
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, 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("  disabled_by_default: ");
+  out.append(YESNO(this->disabled_by_default));
+  out.append("\n");
+
+  out.append("  entity_category: ");
+  out.append(proto_enum_to_string<enums::EntityCategory>(this->entity_category));
+  out.append("\n");
+
+  out.append("  device_class: ");
+  out.append("'").append(this->device_class).append("'");
+  out.append("\n");
+
+  out.append("  assumed_state: ");
+  out.append(YESNO(this->assumed_state));
+  out.append("\n");
+
+  out.append("  supports_position: ");
+  out.append(YESNO(this->supports_position));
+  out.append("\n");
+
+  out.append("  supports_stop: ");
+  out.append(YESNO(this->supports_stop));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool ValveStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 3: {
+      this->current_operation = value.as_enum<enums::ValveOperation>();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ValveStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 2: {
+      this->position = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ValveStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_float(2, this->position);
+  buffer.encode_enum<enums::ValveOperation>(3, this->current_operation);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ValveStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ValveStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  position: ");
+  sprintf(buffer, "%g", this->position);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  current_operation: ");
+  out.append(proto_enum_to_string<enums::ValveOperation>(this->current_operation));
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool ValveCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->has_position = value.as_bool();
+      return true;
+    }
+    case 4: {
+      this->stop = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ValveCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    case 3: {
+      this->position = value.as_float();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ValveCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->has_position);
+  buffer.encode_float(3, this->position);
+  buffer.encode_bool(4, this->stop);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ValveCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ValveCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  has_position: ");
+  out.append(YESNO(this->has_position));
+  out.append("\n");
+
+  out.append("  position: ");
+  sprintf(buffer, "%g", this->position);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  stop: ");
+  out.append(YESNO(this->stop));
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -216,6 +216,11 @@ enum TextMode : uint32_t {
   TEXT_MODE_TEXT = 0,
   TEXT_MODE_PASSWORD = 1,
 };
+enum ValveOperation : uint32_t {
+  VALVE_OPERATION_IDLE = 0,
+  VALVE_OPERATION_IS_OPENING = 1,
+  VALVE_OPERATION_IS_CLOSING = 2,
+};
 
 }  // namespace enums
 
@@ -1969,6 +1974,92 @@ class TimeCommandRequest : public ProtoMessage {
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class ListEntitiesEventResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  std::string device_class{};
+  std::vector<std::string> event_types{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class EventResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  std::string event_type{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+};
+class ListEntitiesValveResponse : public ProtoMessage {
+ public:
+  std::string object_id{};
+  uint32_t key{0};
+  std::string name{};
+  std::string unique_id{};
+  std::string icon{};
+  bool disabled_by_default{false};
+  enums::EntityCategory entity_category{};
+  std::string device_class{};
+  bool assumed_state{false};
+  bool supports_position{false};
+  bool supports_stop{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ValveStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  float position{0.0f};
+  enums::ValveOperation current_operation{};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class ValveCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool has_position{false};
+  float position{0.0f};
+  bool stop{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -557,6 +557,40 @@ bool APIServerConnectionBase::send_time_state_response(const TimeStateResponse &
 #endif
 #ifdef USE_DATETIME_TIME
 #endif
+#ifdef USE_EVENT
+bool APIServerConnectionBase::send_list_entities_event_response(const ListEntitiesEventResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_event_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesEventResponse>(msg, 107);
+}
+#endif
+#ifdef USE_EVENT
+bool APIServerConnectionBase::send_event_response(const EventResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_event_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<EventResponse>(msg, 108);
+}
+#endif
+#ifdef USE_VALVE
+bool APIServerConnectionBase::send_list_entities_valve_response(const ListEntitiesValveResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_valve_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesValveResponse>(msg, 109);
+}
+#endif
+#ifdef USE_VALVE
+bool APIServerConnectionBase::send_valve_state_response(const ValveStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_valve_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ValveStateResponse>(msg, 110);
+}
+#endif
+#ifdef USE_VALVE
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -1019,6 +1053,17 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_voice_assistant_audio: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_audio(msg);
+#endif
+      break;
+    }
+    case 111: {
+#ifdef USE_VALVE
+      ValveCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_valve_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_valve_command_request(msg);
 #endif
       break;
     }
@@ -1282,6 +1327,19 @@ void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg)
   this->lock_command(msg);
 }
 #endif
+#ifdef USE_VALVE
+void APIServerConnection::on_valve_command_request(const ValveCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->valve_command(msg);
+}
+#endif
 #ifdef USE_MEDIA_PLAYER
 void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
   if (!this->is_connection_setup()) {

esphome/components/api/api_pb2_service.h

@@ -279,6 +279,21 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_DATETIME_TIME
   virtual void on_time_command_request(const TimeCommandRequest &value){};
+#endif
+#ifdef USE_EVENT
+  bool send_list_entities_event_response(const ListEntitiesEventResponse &msg);
+#endif
+#ifdef USE_EVENT
+  bool send_event_response(const EventResponse &msg);
+#endif
+#ifdef USE_VALVE
+  bool send_list_entities_valve_response(const ListEntitiesValveResponse &msg);
+#endif
+#ifdef USE_VALVE
+  bool send_valve_state_response(const ValveStateResponse &msg);
+#endif
+#ifdef USE_VALVE
+  virtual void on_valve_command_request(const ValveCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -331,6 +346,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_LOCK
   virtual void lock_command(const LockCommandRequest &msg) = 0;
 #endif
+#ifdef USE_VALVE
+  virtual void valve_command(const ValveCommandRequest &msg) = 0;
+#endif
 #ifdef USE_MEDIA_PLAYER
   virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
 #endif
@@ -423,6 +441,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_LOCK
   void on_lock_command_request(const LockCommandRequest &msg) override;
 #endif
+#ifdef USE_VALVE
+  void on_valve_command_request(const ValveCommandRequest &msg) override;
+#endif
 #ifdef USE_MEDIA_PLAYER
   void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
 #endif

esphome/components/api/api_server.cpp

@@ -300,6 +300,15 @@ void APIServer::on_lock_update(lock::Lock *obj) {
 }
 #endif
 
+#ifdef USE_VALVE
+void APIServer::on_valve_update(valve::Valve *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_valve_state(obj);
+}
+#endif
+
 #ifdef USE_MEDIA_PLAYER
 void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
   if (obj->is_internal())
@@ -309,6 +318,13 @@ void APIServer::on_media_player_update(media_player::MediaPlayer *obj) {
 }
 #endif
 
+#ifdef USE_EVENT
+void APIServer::on_event(event::Event *obj, const std::string &event_type) {
+  for (auto &c : this->clients_)
+    c->send_event(obj, event_type);
+}
+#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;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/api/api_server.h

@@ -81,6 +81,9 @@ class APIServer : public Component, public Controller {
 #ifdef USE_LOCK
   void on_lock_update(lock::Lock *obj) override;
 #endif
+#ifdef USE_VALVE
+  void on_valve_update(valve::Valve *obj) override;
+#endif
 #ifdef USE_MEDIA_PLAYER
   void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
@@ -93,6 +96,9 @@ class APIServer : public Component, public Controller {
 #ifdef USE_ALARM_CONTROL_PANEL
   void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) override;
 #endif
+#ifdef USE_EVENT
+  void on_event(event::Event *obj, const std::string &event_type) override;
+#endif
 
   bool is_connected() const;
 

esphome/components/api/list_entities.cpp

@@ -38,6 +38,9 @@ bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor)
 #ifdef USE_LOCK
 bool ListEntitiesIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_info(a_lock); }
 #endif
+#ifdef USE_VALVE
+bool ListEntitiesIterator::on_valve(valve::Valve *valve) { return this->client_->send_valve_info(valve); }
+#endif
 
 bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(); }
 ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(client) {}
@@ -86,6 +89,9 @@ bool ListEntitiesIterator::on_alarm_control_panel(alarm_control_panel::AlarmCont
   return this->client_->send_alarm_control_panel_info(a_alarm_control_panel);
 }
 #endif
+#ifdef USE_EVENT
+bool ListEntitiesIterator::on_event(event::Event *event) { return this->client_->send_event_info(event); }
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/list_entities.h

@@ -61,11 +61,17 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
 #endif
+#ifdef USE_VALVE
+  bool on_valve(valve::Valve *valve) override;
+#endif
 #ifdef USE_MEDIA_PLAYER
   bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
   bool on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) override;
+#endif
+#ifdef USE_EVENT
+  bool on_event(event::Event *event) override;
 #endif
   bool on_end() override;
 

esphome/components/api/subscribe_state.cpp

@@ -59,6 +59,9 @@ bool InitialStateIterator::on_select(select::Select *select) {
 #ifdef USE_LOCK
 bool InitialStateIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_state(a_lock, a_lock->state); }
 #endif
+#ifdef USE_VALVE
+bool InitialStateIterator::on_valve(valve::Valve *valve) { return this->client_->send_valve_state(valve); }
+#endif
 #ifdef USE_MEDIA_PLAYER
 bool InitialStateIterator::on_media_player(media_player::MediaPlayer *media_player) {
   return this->client_->send_media_player_state(media_player);

esphome/components/api/subscribe_state.h

@@ -58,11 +58,17 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_LOCK
   bool on_lock(lock::Lock *a_lock) override;
 #endif
+#ifdef USE_VALVE
+  bool on_valve(valve::Valve *valve) override;
+#endif
 #ifdef USE_MEDIA_PLAYER
   bool on_media_player(media_player::MediaPlayer *media_player) override;
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
   bool on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) override;
+#endif
+#ifdef USE_EVENT
+  bool on_event(event::Event *event) override { return true; };
 #endif
  protected:
   APIConnection *client_;

esphome/components/climate/__init__.py

@@ -244,122 +244,150 @@ async def setup_climate_core_(var, config):
     await setup_entity(var, config)
 
     visual = config[CONF_VISUAL]
-    if CONF_MIN_TEMPERATURE in visual:
+    if (min_temp := visual.get(CONF_MIN_TEMPERATURE)) is not None:
-        cg.add(var.set_visual_min_temperature_override(visual[CONF_MIN_TEMPERATURE]))
+        cg.add(var.set_visual_min_temperature_override(min_temp))
-    if CONF_MAX_TEMPERATURE in visual:
+    if (max_temp := visual.get(CONF_MAX_TEMPERATURE)) is not None:
-        cg.add(var.set_visual_max_temperature_override(visual[CONF_MAX_TEMPERATURE]))
+        cg.add(var.set_visual_max_temperature_override(max_temp))
-    if CONF_TEMPERATURE_STEP in visual:
+    if (temp_step := visual.get(CONF_TEMPERATURE_STEP)) is not None:
         cg.add(
             var.set_visual_temperature_step_override(
-                visual[CONF_TEMPERATURE_STEP][CONF_TARGET_TEMPERATURE],
+                temp_step[CONF_TARGET_TEMPERATURE],
-                visual[CONF_TEMPERATURE_STEP][CONF_CURRENT_TEMPERATURE],
+                temp_step[CONF_CURRENT_TEMPERATURE],
             )
         )
-    if CONF_MIN_HUMIDITY in visual:
+    if (min_humidity := visual.get(CONF_MIN_HUMIDITY)) is not None:
-        cg.add(var.set_visual_min_humidity_override(visual[CONF_MIN_HUMIDITY]))
+        cg.add(var.set_visual_min_humidity_override(min_humidity))
-    if CONF_MAX_HUMIDITY in visual:
+    if (max_humidity := visual.get(CONF_MAX_HUMIDITY)) is not None:
-        cg.add(var.set_visual_max_humidity_override(visual[CONF_MAX_HUMIDITY]))
+        cg.add(var.set_visual_max_humidity_override(max_humidity))
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-        if CONF_ACTION_STATE_TOPIC in config:
+        if (action_state_topic := config.get(CONF_ACTION_STATE_TOPIC)) is not None:
-            cg.add(mqtt_.set_custom_action_state_topic(config[CONF_ACTION_STATE_TOPIC]))
+            cg.add(mqtt_.set_custom_action_state_topic(action_state_topic))
-        if CONF_AWAY_COMMAND_TOPIC in config:
+        if (away_command_topic := config.get(CONF_AWAY_COMMAND_TOPIC)) is not None:
-            cg.add(mqtt_.set_custom_away_command_topic(config[CONF_AWAY_COMMAND_TOPIC]))
+            cg.add(mqtt_.set_custom_away_command_topic(away_command_topic))
-        if CONF_AWAY_STATE_TOPIC in config:
+        if (away_state_topic := config.get(CONF_AWAY_STATE_TOPIC)) is not None:
-            cg.add(mqtt_.set_custom_away_state_topic(config[CONF_AWAY_STATE_TOPIC]))
+            cg.add(mqtt_.set_custom_away_state_topic(away_state_topic))
-        if CONF_CURRENT_TEMPERATURE_STATE_TOPIC in config:
+        if (
+            current_temperature_state_topic := config.get(
+                CONF_CURRENT_TEMPERATURE_STATE_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_current_temperature_state_topic(
-                    config[CONF_CURRENT_TEMPERATURE_STATE_TOPIC]
+                    current_temperature_state_topic
                 )
             )
-        if CONF_CURRENT_HUMIDITY_STATE_TOPIC in config:
+        if (
+            current_humidity_state_topic := config.get(
+                CONF_CURRENT_HUMIDITY_STATE_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_current_humidity_state_topic(
-                    config[CONF_CURRENT_HUMIDITY_STATE_TOPIC]
+                    current_humidity_state_topic
                 )
             )
-        if CONF_FAN_MODE_COMMAND_TOPIC in config:
+        if (
-            cg.add(
+            fan_mode_command_topic := config.get(CONF_FAN_MODE_COMMAND_TOPIC)
-                mqtt_.set_custom_fan_mode_command_topic(
+        ) is not None:
-                    config[CONF_FAN_MODE_COMMAND_TOPIC]
+            cg.add(mqtt_.set_custom_fan_mode_command_topic(fan_mode_command_topic))
+        if (fan_mode_state_topic := config.get(CONF_FAN_MODE_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_fan_mode_state_topic(fan_mode_state_topic))
+        if (mode_command_topic := config.get(CONF_MODE_COMMAND_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_mode_command_topic(mode_command_topic))
+        if (mode_state_topic := config.get(CONF_MODE_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_mode_state_topic(mode_state_topic))
+        if (preset_command_topic := config.get(CONF_PRESET_COMMAND_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_preset_command_topic(preset_command_topic))
+        if (preset_state_topic := config.get(CONF_PRESET_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_preset_state_topic(preset_state_topic))
+        if (
+            swing_mode_command_topic := config.get(CONF_SWING_MODE_COMMAND_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_swing_mode_command_topic(swing_mode_command_topic))
+        if (
+            swing_mode_state_topic := config.get(CONF_SWING_MODE_STATE_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_swing_mode_state_topic(swing_mode_state_topic))
+        if (
+            target_temperature_command_topic := config.get(
+                CONF_TARGET_TEMPERATURE_COMMAND_TOPIC
             )
-            )
+        ) is not None:
-        if CONF_FAN_MODE_STATE_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_fan_mode_state_topic(config[CONF_FAN_MODE_STATE_TOPIC])
-            )
-        if CONF_MODE_COMMAND_TOPIC in config:
-            cg.add(mqtt_.set_custom_mode_command_topic(config[CONF_MODE_COMMAND_TOPIC]))
-        if CONF_MODE_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_mode_state_topic(config[CONF_MODE_STATE_TOPIC]))
-        if CONF_PRESET_COMMAND_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_preset_command_topic(config[CONF_PRESET_COMMAND_TOPIC])
-            )
-        if CONF_PRESET_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_preset_state_topic(config[CONF_PRESET_STATE_TOPIC]))
-        if CONF_SWING_MODE_COMMAND_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_swing_mode_command_topic(
-                    config[CONF_SWING_MODE_COMMAND_TOPIC]
-                )
-            )
-        if CONF_SWING_MODE_STATE_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_swing_mode_state_topic(
-                    config[CONF_SWING_MODE_STATE_TOPIC]
-                )
-            )
-        if CONF_TARGET_TEMPERATURE_COMMAND_TOPIC in config:
             cg.add(
                 mqtt_.set_custom_target_temperature_command_topic(
-                    config[CONF_TARGET_TEMPERATURE_COMMAND_TOPIC]
+                    target_temperature_command_topic
                 )
             )
-        if CONF_TARGET_TEMPERATURE_STATE_TOPIC in config:
+        if (
+            target_temperature_state_topic := config.get(
+                CONF_TARGET_TEMPERATURE_STATE_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_temperature_state_topic(
-                    config[CONF_TARGET_TEMPERATURE_STATE_TOPIC]
+                    target_temperature_state_topic
                 )
             )
-        if CONF_TARGET_TEMPERATURE_HIGH_COMMAND_TOPIC in config:
+        if (
+            target_temperature_high_command_topic := config.get(
+                CONF_TARGET_TEMPERATURE_HIGH_COMMAND_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_temperature_high_command_topic(
-                    config[CONF_TARGET_TEMPERATURE_HIGH_COMMAND_TOPIC]
+                    target_temperature_high_command_topic
                 )
             )
-        if CONF_TARGET_TEMPERATURE_HIGH_STATE_TOPIC in config:
+        if (
+            target_temperature_high_state_topic := config.get(
+                CONF_TARGET_TEMPERATURE_HIGH_STATE_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_temperature_high_state_topic(
-                    config[CONF_TARGET_TEMPERATURE_HIGH_STATE_TOPIC]
+                    target_temperature_high_state_topic
                 )
             )
-        if CONF_TARGET_TEMPERATURE_LOW_COMMAND_TOPIC in config:
+        if (
+            target_temperature_low_command_topic := config.get(
+                CONF_TARGET_TEMPERATURE_LOW_COMMAND_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_temperature_low_command_topic(
-                    config[CONF_TARGET_TEMPERATURE_LOW_COMMAND_TOPIC]
+                    target_temperature_low_command_topic
                 )
             )
-        if CONF_TARGET_TEMPERATURE_LOW_STATE_TOPIC in config:
+        if (
+            target_temperature_low_state_topic := config.get(
+                CONF_TARGET_TEMPERATURE_LOW_STATE_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_temperature_state_topic(
-                    config[CONF_TARGET_TEMPERATURE_LOW_STATE_TOPIC]
+                    target_temperature_low_state_topic
                 )
             )
-        if CONF_TARGET_HUMIDITY_COMMAND_TOPIC in config:
+        if (
+            target_humidity_command_topic := config.get(
+                CONF_TARGET_HUMIDITY_COMMAND_TOPIC
+            )
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_humidity_command_topic(
-                    config[CONF_TARGET_HUMIDITY_COMMAND_TOPIC]
+                    target_humidity_command_topic
                 )
             )
-        if CONF_TARGET_HUMIDITY_STATE_TOPIC in config:
+        if (
+            target_humidity_state_topic := config.get(CONF_TARGET_HUMIDITY_STATE_TOPIC)
+        ) is not None:
             cg.add(
                 mqtt_.set_custom_target_humidity_state_topic(
-                    config[CONF_TARGET_HUMIDITY_STATE_TOPIC]
+                    target_humidity_state_topic
                 )
             )
 
@@ -411,45 +439,35 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 async def climate_control_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    if CONF_MODE in config:
+    if (mode := config.get(CONF_MODE)) is not None:
-        template_ = await cg.templatable(config[CONF_MODE], args, ClimateMode)
+        template_ = await cg.templatable(mode, args, ClimateMode)
         cg.add(var.set_mode(template_))
-    if CONF_TARGET_TEMPERATURE in config:
+    if (target_temp := config.get(CONF_TARGET_TEMPERATURE)) is not None:
-        template_ = await cg.templatable(config[CONF_TARGET_TEMPERATURE], args, float)
+        template_ = await cg.templatable(target_temp, args, float)
         cg.add(var.set_target_temperature(template_))
-    if CONF_TARGET_TEMPERATURE_LOW in config:
+    if (target_temp_low := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
-        template_ = await cg.templatable(
+        template_ = await cg.templatable(target_temp_low, args, float)
-            config[CONF_TARGET_TEMPERATURE_LOW], args, float
-        )
         cg.add(var.set_target_temperature_low(template_))
-    if CONF_TARGET_TEMPERATURE_HIGH in config:
+    if (target_temp_high := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
-        template_ = await cg.templatable(
+        template_ = await cg.templatable(target_temp_high, args, float)
-            config[CONF_TARGET_TEMPERATURE_HIGH], args, float
-        )
         cg.add(var.set_target_temperature_high(template_))
-    if CONF_TARGET_HUMIDITY in config:
+    if (target_humidity := config.get(CONF_TARGET_HUMIDITY)) is not None:
-        template_ = await cg.templatable(config[CONF_TARGET_HUMIDITY], args, float)
+        template_ = await cg.templatable(target_humidity, args, float)
         cg.add(var.set_target_humidity(template_))
-    if CONF_FAN_MODE in config:
+    if (fan_mode := config.get(CONF_FAN_MODE)) is not None:
-        template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
+        template_ = await cg.templatable(fan_mode, args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))
-    if CONF_CUSTOM_FAN_MODE in config:
+    if (custom_fan_mode := config.get(CONF_CUSTOM_FAN_MODE)) is not None:
-        template_ = await cg.templatable(
+        template_ = await cg.templatable(custom_fan_mode, args, cg.std_string)
-            config[CONF_CUSTOM_FAN_MODE], args, cg.std_string
-        )
         cg.add(var.set_custom_fan_mode(template_))
-    if CONF_PRESET in config:
+    if (preset := config.get(CONF_PRESET)) is not None:
-        template_ = await cg.templatable(config[CONF_PRESET], args, ClimatePreset)
+        template_ = await cg.templatable(preset, args, ClimatePreset)
         cg.add(var.set_preset(template_))
-    if CONF_CUSTOM_PRESET in config:
+    if (custom_preset := config.get(CONF_CUSTOM_PRESET)) is not None:
-        template_ = await cg.templatable(
+        template_ = await cg.templatable(custom_preset, args, cg.std_string)
-            config[CONF_CUSTOM_PRESET], args, cg.std_string
-        )
         cg.add(var.set_custom_preset(template_))
-    if CONF_SWING_MODE in config:
+    if (swing_mode := config.get(CONF_SWING_MODE)) is not None:
-        template_ = await cg.templatable(
+        template_ = await cg.templatable(swing_mode, args, ClimateSwingMode)
-            config[CONF_SWING_MODE], args, ClimateSwingMode
-        )
         cg.add(var.set_swing_mode(template_))
     return var
 

esphome/components/cover/__init__.py

@@ -122,8 +122,8 @@ COVER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA).ex
 async def setup_cover_core_(var, config):
     await setup_entity(var, config)
 
-    if CONF_DEVICE_CLASS in config:
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+        cg.add(var.set_device_class(device_class))
 
     for conf in config.get(CONF_ON_OPEN, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
@@ -132,24 +132,20 @@ async def setup_cover_core_(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-        if CONF_POSITION_STATE_TOPIC in config:
+        if (position_state_topic := config.get(CONF_POSITION_STATE_TOPIC)) is not None:
-            cg.add(
+            cg.add(mqtt_.set_custom_position_state_topic(position_state_topic))
-                mqtt_.set_custom_position_state_topic(config[CONF_POSITION_STATE_TOPIC])
+        if (
-            )
+            position_command_topic := config.get(CONF_POSITION_COMMAND_TOPIC)
-        if CONF_POSITION_COMMAND_TOPIC in config:
+        ) is not None:
-            cg.add(
+            cg.add(mqtt_.set_custom_position_command_topic(position_command_topic))
-                mqtt_.set_custom_position_command_topic(
+        if (tilt_state_topic := config.get(CONF_TILT_STATE_TOPIC)) is not None:
-                    config[CONF_POSITION_COMMAND_TOPIC]
+            cg.add(mqtt_.set_custom_tilt_state_topic(tilt_state_topic))
-                )
+        if (tilt_command_topic := config.get(CONF_TILT_COMMAND_TOPIC)) is not None:
-            )
+            cg.add(mqtt_.set_custom_tilt_command_topic(tilt_command_topic))
-        if CONF_TILT_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_tilt_state_topic(config[CONF_TILT_STATE_TOPIC]))
-        if CONF_TILT_COMMAND_TOPIC in config:
-            cg.add(mqtt_.set_custom_tilt_command_topic(config[CONF_TILT_COMMAND_TOPIC]))
 
 
 async def register_cover(var, config):
@@ -205,17 +201,17 @@ COVER_CONTROL_ACTION_SCHEMA = cv.Schema(
 async def cover_control_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    if CONF_STOP in config:
+    if (stop := config.get(CONF_STOP)) is not None:
-        template_ = await cg.templatable(config[CONF_STOP], args, bool)
+        template_ = await cg.templatable(stop, args, bool)
         cg.add(var.set_stop(template_))
-    if CONF_STATE in config:
+    if (state := config.get(CONF_STATE)) is not None:
-        template_ = await cg.templatable(config[CONF_STATE], args, float)
+        template_ = await cg.templatable(state, args, float)
         cg.add(var.set_position(template_))
-    if CONF_POSITION in config:
+    if (position := config.get(CONF_POSITION)) is not None:
-        template_ = await cg.templatable(config[CONF_POSITION], args, float)
+        template_ = await cg.templatable(position, args, float)
         cg.add(var.set_position(template_))
-    if CONF_TILT in config:
+    if (tilt := config.get(CONF_TILT)) is not None:
-        template_ = await cg.templatable(config[CONF_TILT], args, float)
+        template_ = await cg.templatable(tilt, args, float)
         cg.add(var.set_tilt(template_))
     return var
 

esphome/components/cst226/touchscreen/cst226_touchscreen.cpp

@@ -5,7 +5,6 @@ namespace cst226 {
 
 void CST226Touchscreen::setup() {
   esph_log_config(TAG, "Setting up CST226 Touchscreen...");
-  if (this->reset_pin_ != nullptr) {
   this->reset_pin_->setup();
   this->reset_pin_->digital_write(true);
   delay(5);
@@ -13,9 +12,6 @@ void CST226Touchscreen::setup() {
   delay(5);
   this->reset_pin_->digital_write(true);
   this->set_timeout(30, [this] { this->continue_setup_(); });
-  } else {
-    this->continue_setup_();
-  }
 }
 
 void CST226Touchscreen::update_touches() {

esphome/components/cst226/touchscreen/cst226_touchscreen.h

@@ -35,7 +35,7 @@ class CST226Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice
   void continue_setup_();
 
   InternalGPIOPin *interrupt_pin_{};
-  GPIOPin *reset_pin_{};
+  GPIOPin *reset_pin_{NULL_PIN};
   uint8_t chip_id_{};
   bool setup_complete_{};
 };

esphome/components/dallas/dallas_component.cpp

@@ -60,7 +60,7 @@ void DallasComponent::setup() {
   for (auto *sensor : this->sensors_) {
     if (sensor->get_index().has_value()) {
       if (*sensor->get_index() >= this->found_sensors_.size()) {
-        this->status_set_error();
+        this->status_set_error("Sensor configured by index but not found");
         continue;
       }
       sensor->set_address(this->found_sensors_[*sensor->get_index()]);
@@ -109,8 +109,12 @@ void DallasComponent::update() {
     result = this->one_wire_->reset();
   }
   if (!result) {
+    if (!this->found_sensors_.empty()) {
+      // Only log error if at the start sensors were found (and thus are disconnected during uptime)
       ESP_LOGE(TAG, "Requesting conversion failed");
       this->status_set_warning();
+    }
+
     for (auto *sensor : this->sensors_) {
       sensor->publish_state(NAN);
     }
@@ -124,6 +128,12 @@ void DallasComponent::update() {
   }
 
   for (auto *sensor : this->sensors_) {
+    if (sensor->get_address() == 0) {
+      ESP_LOGV(TAG, "'%s' - Indexed sensor not found at startup, skipping update", sensor->get_name().c_str());
+      sensor->publish_state(NAN);
+      continue;
+    }
+
     this->set_timeout(sensor->get_address_name(), sensor->millis_to_wait_for_conversion(), [this, sensor] {
       bool res = sensor->read_scratch_pad();
 
@@ -152,6 +162,8 @@ void DallasTemperatureSensor::set_resolution(uint8_t resolution) { this->resolut
 optional<uint8_t> DallasTemperatureSensor::get_index() const { return this->index_; }
 void DallasTemperatureSensor::set_index(uint8_t index) { this->index_ = index; }
 uint8_t *DallasTemperatureSensor::get_address8() { return reinterpret_cast<uint8_t *>(&this->address_); }
+uint64_t DallasTemperatureSensor::get_address() { return this->address_; }
+
 const std::string &DallasTemperatureSensor::get_address_name() {
   if (this->address_name_.empty()) {
     this->address_name_ = std::string("0x") + format_hex(this->address_);

esphome/components/dallas/dallas_component.h

@@ -37,6 +37,7 @@ class DallasTemperatureSensor : public sensor::Sensor {
   void set_parent(DallasComponent *parent) { parent_ = parent; }
   /// Helper to get a pointer to the address as uint8_t.
   uint8_t *get_address8();
+  uint64_t get_address();
   /// Helper to create (and cache) the name for this sensor. For example "0xfe0000031f1eaf29".
   const std::string &get_address_name();
 

esphome/components/datetime/__init__.py

@@ -106,8 +106,8 @@ def datetime_schema(class_: MockObjClass) -> cv.Schema:
 async def setup_datetime_core_(var, config):
     await setup_entity(var, config)
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)

esphome/components/esp32/__init__.py

@@ -316,17 +316,26 @@ def _parse_platform_version(value):
 
 
 def _detect_variant(value):
-    if CONF_VARIANT not in value:
     board = value[CONF_BOARD]
-        if board not in BOARDS:
+    if board in BOARDS:
+        variant = BOARDS[board][KEY_VARIANT]
+        if CONF_VARIANT in value and variant != value[CONF_VARIANT]:
             raise cv.Invalid(
-                "This board is unknown, please set the variant manually",
+                f"Option '{CONF_VARIANT}' does not match selected board.",
+                path=[CONF_VARIANT],
+            )
+        value = value.copy()
+        value[CONF_VARIANT] = variant
+    else:
+        if CONF_VARIANT not in value:
+            raise cv.Invalid(
+                "This board is unknown, if you are sure you want to compile with this board selection, "
+                f"override with option '{CONF_VARIANT}'",
                 path=[CONF_BOARD],
             )
-
+        _LOGGER.warning(
-        value = value.copy()
+            "This board is unknown. Make sure the chosen chip component is correct.",
-        value[CONF_VARIANT] = BOARDS[board][KEY_VARIANT]
+        )
-
     return value
 
 

esphome/components/esp32_ble/__init__.py

@@ -65,6 +65,8 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
         add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
 
+    cg.add_define("USE_ESP32_BLE")
+
 
 @automation.register_condition("ble.enabled", BLEEnabledCondition, cv.Schema({}))
 async def ble_enabled_to_code(config, condition_id, template_arg, args):

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -364,7 +364,11 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
 }
 
 void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
+  if (param.status == ESP_BT_STATUS_DONE) {
+    this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
+  } else {
     this->scan_set_param_failed_ = param.status;
+  }
 }
 
 void ESP32BLETracker::gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -2,6 +2,7 @@
 
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 
 #include <array>
@@ -248,11 +249,11 @@ class ESP32BLETracker : public Component,
   SemaphoreHandle_t scan_result_lock_;
   SemaphoreHandle_t scan_end_lock_;
   size_t scan_result_index_{0};
-#if CONFIG_SPIRAM
+#ifdef USE_PSRAM
   const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 32;
 #else
   const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 16;
-#endif  // CONFIG_SPIRAM
+#endif  // USE_PSRAM
   esp_ble_gap_cb_param_t::ble_scan_result_evt_param *scan_result_buffer_;
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
   esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};

esphome/components/esp32_rmt_led_strip/led_strip.h

@@ -64,7 +64,7 @@ class ESP32RMTLEDStripLightOutput : public light::AddressableLight {
  protected:
   light::ESPColorView get_view_internal(int32_t index) const override;
 
-  size_t get_buffer_size_() const { return this->num_leds_ * (3 + this->is_rgbw_); }
+  size_t get_buffer_size_() const { return this->num_leds_ * (this->is_rgbw_ || this->is_wrgb_ ? 4 : 3); }
 
   uint8_t *buf_{nullptr};
   uint8_t *effect_data_{nullptr};

esphome/components/esp32_rmt_led_strip/light.py

@@ -48,7 +48,7 @@ CHIPSETS = {
     "WS2812": LEDStripTimings(400, 1000, 1000, 400),
     "SK6812": LEDStripTimings(300, 900, 600, 600),
     "APA106": LEDStripTimings(350, 1360, 1360, 350),
-    "SM16703": LEDStripTimings(300, 900, 1360, 350),
+    "SM16703": LEDStripTimings(300, 900, 900, 300),
 }
 
 

esphome/components/ethernet/ethernet_component.cpp

@@ -340,6 +340,11 @@ network::IPAddresses EthernetComponent::get_ip_addresses() {
   return addresses;
 }
 
+network::IPAddress EthernetComponent::get_dns_address(uint8_t num) {
+  const ip_addr_t *dns_ip = dns_getserver(num);
+  return dns_ip;
+}
+
 void EthernetComponent::eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event, void *event_data) {
   const char *event_name;
 

esphome/components/ethernet/ethernet_component.h

@@ -70,6 +70,7 @@ class EthernetComponent : public Component {
   void set_manual_ip(const ManualIP &manual_ip);
 
   network::IPAddresses get_ip_addresses();
+  network::IPAddress get_dns_address(uint8_t num);
   std::string get_use_address() const;
   void set_use_address(const std::string &use_address);
   bool powerdown();

esphome/components/ethernet_info/ethernet_info_text_sensor.cpp

@@ -9,6 +9,7 @@ namespace ethernet_info {
 static const char *const TAG = "ethernet_info";
 
 void IPAddressEthernetInfo::dump_config() { LOG_TEXT_SENSOR("", "EthernetInfo IPAddress", this); }
+void DNSAddressEthernetInfo::dump_config() { LOG_TEXT_SENSOR("", "EthernetInfo DNS Address", this); }
 
 }  // namespace ethernet_info
 }  // namespace esphome

esphome/components/ethernet_info/ethernet_info_text_sensor.h

@@ -38,6 +38,27 @@ class IPAddressEthernetInfo : public PollingComponent, public text_sensor::TextS
   std::array<text_sensor::TextSensor *, 5> ip_sensors_;
 };
 
+class DNSAddressEthernetInfo : public PollingComponent, public text_sensor::TextSensor {
+ public:
+  void update() override {
+    auto dns_one = ethernet::global_eth_component->get_dns_address(0);
+    auto dns_two = ethernet::global_eth_component->get_dns_address(1);
+
+    std::string dns_results = dns_one.str() + " " + dns_two.str();
+
+    if (dns_results != this->last_results_) {
+      this->last_results_ = dns_results;
+      this->publish_state(dns_results);
+    }
+  }
+  float get_setup_priority() const override { return setup_priority::ETHERNET; }
+  std::string unique_id() override { return get_mac_address() + "-ethernetinfo-dns"; }
+  void dump_config() override;
+
+ protected:
+  std::string last_results_;
+};
+
 }  // namespace ethernet_info
 }  // namespace esphome
 

esphome/components/ethernet_info/text_sensor.py

@@ -3,6 +3,7 @@ import esphome.config_validation as cv
 from esphome.components import text_sensor
 from esphome.const import (
     CONF_IP_ADDRESS,
+    CONF_DNS_ADDRESS,
     ENTITY_CATEGORY_DIAGNOSTIC,
 )
 
@@ -10,14 +11,18 @@ DEPENDENCIES = ["ethernet"]
 
 ethernet_info_ns = cg.esphome_ns.namespace("ethernet_info")
 
-IPAddressEsthernetInfo = ethernet_info_ns.class_(
+IPAddressEthernetInfo = ethernet_info_ns.class_(
     "IPAddressEthernetInfo", text_sensor.TextSensor, cg.PollingComponent
 )
 
+DNSAddressEthernetInfo = ethernet_info_ns.class_(
+    "DNSAddressEthernetInfo", text_sensor.TextSensor, cg.PollingComponent
+)
+
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.Optional(CONF_IP_ADDRESS): text_sensor.text_sensor_schema(
-            IPAddressEsthernetInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+            IPAddressEthernetInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
         )
         .extend(cv.polling_component_schema("1s"))
         .extend(
@@ -27,7 +32,10 @@ CONFIG_SCHEMA = cv.Schema(
                 )
                 for x in range(5)
             }
-        )
+        ),
+        cv.Optional(CONF_DNS_ADDRESS): text_sensor.text_sensor_schema(
+            DNSAddressEthernetInfo, entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+        ).extend(cv.polling_component_schema("1s")),
     }
 )
 
@@ -40,3 +48,6 @@ async def to_code(config):
             if sensor_conf := conf.get(f"address_{x}"):
                 sens = await text_sensor.new_text_sensor(sensor_conf)
                 cg.add(ip_info.add_ip_sensors(x, sens))
+    if conf := config.get(CONF_DNS_ADDRESS):
+        dns_info = await text_sensor.new_text_sensor(config[CONF_DNS_ADDRESS])
+        await cg.register_component(dns_info, config[CONF_DNS_ADDRESS])

esphome/components/event/__init__.py

@@ -0,0 +1,134 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.components import mqtt
+from esphome.const import (
+    CONF_DEVICE_CLASS,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
+    CONF_ID,
+    CONF_ON_EVENT,
+    CONF_TRIGGER_ID,
+    CONF_MQTT_ID,
+    CONF_EVENT_TYPE,
+    DEVICE_CLASS_BUTTON,
+    DEVICE_CLASS_DOORBELL,
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_MOTION,
+)
+from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_helpers import setup_entity
+from esphome.cpp_generator import MockObjClass
+
+CODEOWNERS = ["@nohat"]
+IS_PLATFORM_COMPONENT = True
+
+DEVICE_CLASSES = [
+    DEVICE_CLASS_BUTTON,
+    DEVICE_CLASS_EMPTY,
+    DEVICE_CLASS_DOORBELL,
+    DEVICE_CLASS_MOTION,
+]
+
+event_ns = cg.esphome_ns.namespace("event")
+Event = event_ns.class_("Event", cg.EntityBase)
+EventPtr = Event.operator("ptr")
+
+TriggerEventAction = event_ns.class_("TriggerEventAction", automation.Action)
+
+EventTrigger = event_ns.class_("EventTrigger", automation.Trigger.template())
+
+validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
+
+EVENT_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(cv.MQTT_COMPONENT_SCHEMA).extend(
+    {
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTEventComponent),
+        cv.GenerateID(): cv.declare_id(Event),
+        cv.Optional(CONF_DEVICE_CLASS): validate_device_class,
+        cv.Optional(CONF_ON_EVENT): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(EventTrigger),
+            }
+        ),
+    }
+)
+
+_UNDEF = object()
+
+
+def event_schema(
+    class_: MockObjClass = _UNDEF,
+    *,
+    icon: str = _UNDEF,
+    entity_category: str = _UNDEF,
+    device_class: str = _UNDEF,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not _UNDEF:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_DEVICE_CLASS, device_class, validate_device_class),
+    ]:
+        if default is not _UNDEF:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return EVENT_SCHEMA.extend(schema)
+
+
+async def setup_event_core_(var, config, *, event_types: list[str]):
+    await setup_entity(var, config)
+
+    for conf in config.get(CONF_ON_EVENT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger, [(cg.std_string, "event_type")], conf
+        )
+
+    cg.add(var.set_event_types(event_types))
+
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        cg.add(var.set_device_class(device_class))
+
+    if mqtt_id := config.get(CONF_MQTT_ID):
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
+
+async def register_event(var, config, *, event_types: list[str]):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_event(var))
+    await setup_event_core_(var, config, event_types=event_types)
+
+
+async def new_event(config, *, event_types: list[str]):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await register_event(var, config, event_types=event_types)
+    return var
+
+
+TRIGGER_EVENT_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.use_id(Event),
+        cv.Required(CONF_EVENT_TYPE): cv.templatable(cv.string_strict),
+    }
+)
+
+
+@automation.register_action("event.trigger", TriggerEventAction, TRIGGER_EVENT_SCHEMA)
+async def event_fire_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    templ = await cg.templatable(config[CONF_EVENT_TYPE], args, cg.std_string)
+    cg.add(var.set_event_type(templ))
+    return var
+
+
+@coroutine_with_priority(100.0)
+async def to_code(config):
+    cg.add_define("USE_EVENT")
+    cg.add_global(event_ns.using)

esphome/components/event/automation.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "esphome/components/event/event.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome {
+namespace event {
+
+template<typename... Ts> class TriggerEventAction : public Action<Ts...>, public Parented<Event> {
+ public:
+  TEMPLATABLE_VALUE(std::string, event_type)
+
+  void play(Ts... x) override { this->parent_->trigger(this->event_type_.value(x...)); }
+};
+
+class EventTrigger : public Trigger<std::string> {
+ public:
+  EventTrigger(Event *event) {
+    event->add_on_event_callback([this](const std::string &event_type) { this->trigger(event_type); });
+  }
+};
+
+}  // namespace event
+}  // namespace esphome

esphome/components/event/event.cpp

@@ -0,0 +1,24 @@
+#include "event.h"
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace event {
+
+static const char *const TAG = "event";
+
+void Event::trigger(const std::string &event_type) {
+  if (types_.find(event_type) == types_.end()) {
+    ESP_LOGE(TAG, "'%s': invalid event type for trigger(): %s", this->get_name().c_str(), event_type.c_str());
+    return;
+  }
+  ESP_LOGD(TAG, "'%s' Triggered event '%s'", this->get_name().c_str(), event_type.c_str());
+  this->event_callback_.call(event_type);
+}
+
+void Event::add_on_event_callback(std::function<void(const std::string &event_type)> &&callback) {
+  this->event_callback_.add(std::move(callback));
+}
+
+}  // namespace event
+}  // namespace esphome

esphome/components/event/event.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <set>
+#include <string>
+
+#include "esphome/core/component.h"
+#include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace event {
+
+#define LOG_EVENT(prefix, type, obj) \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
+    } \
+    if (!(obj)->get_device_class().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
+    } \
+  }
+
+class Event : public EntityBase, public EntityBase_DeviceClass {
+ public:
+  void trigger(const std::string &event_type);
+  void set_event_types(const std::set<std::string> &event_types) { this->types_ = event_types; }
+  std::set<std::string> get_event_types() const { return this->types_; }
+  void add_on_event_callback(std::function<void(const std::string &event_type)> &&callback);
+
+ protected:
+  CallbackManager<void(const std::string &event_type)> event_callback_;
+  std::set<std::string> types_;
+};
+
+}  // namespace event
+}  // namespace esphome

esphome/components/fan/__init__.py

@@ -180,40 +180,34 @@ async def setup_fan_core_(var, config):
 
     cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-        if CONF_OSCILLATION_STATE_TOPIC in config:
+        if (
+            oscillation_state_topic := config.get(CONF_OSCILLATION_STATE_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_oscillation_state_topic(oscillation_state_topic))
+        if (
+            oscillation_command_topic := config.get(CONF_OSCILLATION_COMMAND_TOPIC)
+        ) is not None:
             cg.add(
-                mqtt_.set_custom_oscillation_state_topic(
+                mqtt_.set_custom_oscillation_command_topic(oscillation_command_topic)
-                    config[CONF_OSCILLATION_STATE_TOPIC]
             )
-            )
+        if (
-        if CONF_OSCILLATION_COMMAND_TOPIC in config:
+            speed_level_state_topic := config.get(CONF_SPEED_LEVEL_STATE_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_speed_level_state_topic(speed_level_state_topic))
+        if (
+            speed_level_command_topic := config.get(CONF_SPEED_LEVEL_COMMAND_TOPIC)
+        ) is not None:
             cg.add(
-                mqtt_.set_custom_oscillation_command_topic(
+                mqtt_.set_custom_speed_level_command_topic(speed_level_command_topic)
-                    config[CONF_OSCILLATION_COMMAND_TOPIC]
-                )
-            )
-        if CONF_SPEED_LEVEL_STATE_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_speed_level_state_topic(
-                    config[CONF_SPEED_LEVEL_STATE_TOPIC]
-                )
-            )
-        if CONF_SPEED_LEVEL_COMMAND_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_speed_level_command_topic(
-                    config[CONF_SPEED_LEVEL_COMMAND_TOPIC]
-                )
-            )
-        if CONF_SPEED_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_speed_state_topic(config[CONF_SPEED_STATE_TOPIC]))
-        if CONF_SPEED_COMMAND_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_speed_command_topic(config[CONF_SPEED_COMMAND_TOPIC])
             )
+        if (speed_state_topic := config.get(CONF_SPEED_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_speed_state_topic(speed_state_topic))
+        if (speed_command_topic := config.get(CONF_SPEED_COMMAND_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_speed_command_topic(speed_command_topic))
 
     for conf in config.get(CONF_ON_STATE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
@@ -288,14 +282,14 @@ async def fan_turn_off_to_code(config, action_id, template_arg, args):
 async def fan_turn_on_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    if CONF_OSCILLATING in config:
+    if (oscillating := config.get(CONF_OSCILLATING)) is not None:
-        template_ = await cg.templatable(config[CONF_OSCILLATING], args, bool)
+        template_ = await cg.templatable(oscillating, args, bool)
         cg.add(var.set_oscillating(template_))
-    if CONF_SPEED in config:
+    if (speed := config.get(CONF_SPEED)) is not None:
-        template_ = await cg.templatable(config[CONF_SPEED], args, int)
+        template_ = await cg.templatable(speed, args, int)
         cg.add(var.set_speed(template_))
-    if CONF_DIRECTION in config:
+    if (direction := config.get(CONF_DIRECTION)) is not None:
-        template_ = await cg.templatable(config[CONF_DIRECTION], args, FanDirection)
+        template_ = await cg.templatable(direction, args, FanDirection)
         cg.add(var.set_direction(template_))
     return var
 

esphome/components/font/__init__.py

@@ -400,8 +400,7 @@ class BitmapFontWrapper:
         for glyph in glyphs:
             mask = self.getmask(glyph, mode="1")
             _, height = mask.size
-            if height > max_height:
+            max_height = max(max_height, height)
-                max_height = height
         return (max_height, 0)
 
 

esphome/components/ft63x6/ft63x6.cpp

@@ -32,7 +32,7 @@ void FT63X6Touchscreen::setup() {
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
     this->interrupt_pin_->setup();
-    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
+    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_ANY_EDGE);
   }
 
   if (this->reset_pin_ != nullptr) {
@@ -78,13 +78,12 @@ void FT63X6Touchscreen::update_touches() {
   uint16_t touch_id, x, y;
 
   uint8_t touches = this->read_touch_number_();
+  ESP_LOGV(TAG, "Touches found: %d", touches);
   if ((touches == 0x00) || (touches == 0xff)) {
     // ESP_LOGD(TAG, "No touches detected");
     return;
   }
 
-  ESP_LOGV(TAG, "Touches found: %d", touches);
-
   for (auto point = 0; point < touches; point++) {
     if (((this->read_touch_event_(point)) & 0x01) == 0) {  // checking event flag bit 6 if it is null
       touch_id = this->read_touch_id_(point);              // id1 = 0 or 1

esphome/components/graphical_display_menu/__init__.py

@@ -38,7 +38,7 @@ CONFIG_SCHEMA = DISPLAY_MENU_BASE_SCHEMA.extend(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(GraphicalDisplayMenu),
-            cv.Optional(CONF_DISPLAY): cv.use_id(display.DisplayBuffer),
+            cv.Optional(CONF_DISPLAY): cv.use_id(display.Display),
             cv.Required(CONF_FONT): cv.use_id(font.Font),
             cv.Optional(CONF_MENU_ITEM_VALUE): cv.templatable(cv.string),
             cv.Optional(CONF_FOREGROUND_COLOR): cv.use_id(color.ColorStruct),

esphome/components/graphical_display_menu/graphical_display_menu.cpp

@@ -229,7 +229,8 @@ inline void GraphicalDisplayMenu::draw_item(display::Display *display, const dis
     label.append(this->menu_item_value_.value(&args));
   }
 
-  display->print(bounds->x, bounds->y, this->font_, foreground_color, display::TextAlign::TOP_LEFT, label.c_str());
+  display->print(bounds->x, bounds->y, this->font_, foreground_color, display::TextAlign::TOP_LEFT, label.c_str(),
+                 ~foreground_color);
 }
 
 void GraphicalDisplayMenu::draw_item(const display_menu_base::MenuItem *item, const uint8_t row, const bool selected) {

esphome/components/htu21d/htu21d.cpp

@@ -76,12 +76,27 @@ void HTU21DComponent::update() {
 
       float humidity = (float(raw_humidity & 0xFFFC)) * 125.0f / 65536.0f - 6.0f;
 
-      int8_t heater_level = this->get_heater_level();
+      ESP_LOGD(TAG, "Got Humidity=%.1f%%", humidity);
-
-      ESP_LOGD(TAG, "Got Humidity=%.1f%% Heater Level=%d", humidity, heater_level);
 
       if (this->humidity_ != nullptr)
         this->humidity_->publish_state(humidity);
+
+      int8_t heater_level;
+
+      // HTU21D does have a heater module but does not have heater level
+      // Setting heater level to 1 in case the heater is ON
+      if (this->sensor_model_ == HTU21D_SENSOR_MODEL_HTU21D) {
+        if (this->is_heater_enabled()) {
+          heater_level = 1;
+        } else {
+          heater_level = 0;
+        }
+      } else {
+        heater_level = this->get_heater_level();
+      }
+
+      ESP_LOGD(TAG, "Heater Level=%d", heater_level);
+
       if (this->heater_ != nullptr)
         this->heater_->publish_state(heater_level);
       this->status_clear_warning();

esphome/components/htu21d/htu21d.h

@@ -8,6 +8,8 @@
 namespace esphome {
 namespace htu21d {
 
+enum HTU21DSensorModels { HTU21D_SENSOR_MODEL_HTU21D = 0, HTU21D_SENSOR_MODEL_SI7021, HTU21D_SENSOR_MODEL_SHT21 };
+
 class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
  public:
   void set_temperature(sensor::Sensor *temperature) { temperature_ = temperature; }
@@ -17,6 +19,7 @@ class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
   /// Setup (reset) the sensor and check connection.
   void setup() override;
   void dump_config() override;
+  void set_sensor_model(HTU21DSensorModels sensor_model) { sensor_model_ = sensor_model; }
   /// Update the sensor values (temperature+humidity).
   void update() override;
 
@@ -31,6 +34,7 @@ class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
   sensor::Sensor *temperature_{nullptr};
   sensor::Sensor *humidity_{nullptr};
   sensor::Sensor *heater_{nullptr};
+  HTU21DSensorModels sensor_model_{HTU21D_SENSOR_MODEL_HTU21D};
 };
 
 template<typename... Ts> class SetHeaterLevelAction : public Action<Ts...>, public Parented<HTU21DComponent> {

esphome/components/htu21d/sensor.py

@@ -5,6 +5,7 @@ from esphome import automation
 from esphome.const import (
     CONF_HUMIDITY,
     CONF_ID,
+    CONF_MODEL,
     CONF_TEMPERATURE,
     DEVICE_CLASS_HUMIDITY,
     DEVICE_CLASS_TEMPERATURE,
@@ -23,10 +24,15 @@ htu21d_ns = cg.esphome_ns.namespace("htu21d")
 HTU21DComponent = htu21d_ns.class_(
     "HTU21DComponent", cg.PollingComponent, i2c.I2CDevice
 )
-
 SetHeaterLevelAction = htu21d_ns.class_("SetHeaterLevelAction", automation.Action)
 SetHeaterAction = htu21d_ns.class_("SetHeaterAction", automation.Action)
+HTU21DSensorModels = htu21d_ns.enum("HTU21DSensorModels")
 
+MODELS = {
+    "HTU21D": HTU21DSensorModels.HTU21D_SENSOR_MODEL_HTU21D,
+    "SI7021": HTU21DSensorModels.HTU21D_SENSOR_MODEL_SI7021,
+    "SHT21": HTU21DSensorModels.HTU21D_SENSOR_MODEL_SHT21,
+}
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -49,6 +55,7 @@ CONFIG_SCHEMA = (
                 accuracy_decimals=1,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_MODEL, default="HTU21D"): cv.enum(MODELS, upper=True),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -73,6 +80,8 @@ async def to_code(config):
         sens = await sensor.new_sensor(config[CONF_HEATER])
         cg.add(var.set_heater(sens))
 
+    cg.add(var.set_sensor_model(config[CONF_MODEL]))
+
 
 @automation.register_action(
     "htu21d.set_heater_level",

esphome/components/internal_temperature/internal_temperature.cpp

@@ -55,11 +55,13 @@ void InternalTemperatureSensor::update() {
   uint32_t raw, result;
   result = temp_single_get_current_temperature(&raw);
   success = (result == 0);
-#ifdef USE_LIBRETINY_VARIANT_BK7231T
+#if defined(USE_LIBRETINY_VARIANT_BK7231N)
+  temperature = raw * -0.38f + 156.0f;
+#elif defined(USE_LIBRETINY_VARIANT_BK7231T)
   temperature = raw * 0.04f;
-#else
+#else   // USE_LIBRETINY_VARIANT
   temperature = raw * 0.128f;
-#endif  // USE_LIBRETINY_VARIANT_BK7231T
+#endif  // USE_LIBRETINY_VARIANT
 #endif  // USE_BK72XX
   if (success && std::isfinite(temperature)) {
     this->publish_state(temperature);

esphome/components/ld2420/ld2420.cpp

@@ -493,19 +493,16 @@ void LD2420Component::handle_ack_data_(uint8_t *buffer, int len) {
 }
 
 int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
+  uint32_t start_millis = millis();
   uint8_t error = 0;
   uint8_t ack_buffer[64];
   uint8_t cmd_buffer[64];
-  uint16_t loop_count;
   this->cmd_reply_.ack = false;
   if (frame.command != CMD_RESTART)
     this->set_cmd_active_(true);  // Restart does not reply, thus no ack state required.
   uint8_t retry = 3;
   while (retry) {
-    // TODO setup a dynamic method e.g. millis time count etc. to tune for non ESP32 240Mhz devices
-    // this is ok for now since the module firmware is changing like the weather atm
     frame.length = 0;
-    loop_count = 1250;
     uint16_t frame_data_bytes = frame.data_length + 2;  // Always add two bytes for the cmd size
 
     memcpy(&cmd_buffer[frame.length], &frame.header, sizeof(frame.header));
@@ -538,12 +535,13 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
         this->readline_(read(), ack_buffer, sizeof(ack_buffer));
       }
       delay_microseconds_safe(1450);
-      if (loop_count <= 0) {
+      // Wait on an Rx from the LD2420 for up to 3 1 second loops, otherwise it could trigger a WDT.
+      if ((millis() - start_millis) > 1000) {
+        start_millis = millis();
         error = LD2420_ERROR_TIMEOUT;
         retry--;
         break;
       }
-      loop_count--;
     }
     if (this->cmd_reply_.ack)
       retry = 0;

esphome/components/libretiny/__init__.py

@@ -1,6 +1,10 @@
 import json
 import logging
-from os.path import dirname, isfile, join
+from os.path import (
+    dirname,
+    isfile,
+    join,
+)
 
 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -55,15 +59,25 @@ def _detect_variant(value):
     component: LibreTinyComponent = CORE.data[KEY_LIBRETINY][KEY_COMPONENT_DATA]
     board = value[CONF_BOARD]
     # read board-default family if not specified
-    if CONF_FAMILY not in value:
     if board not in component.boards:
+        if CONF_FAMILY not in value:
             raise cv.Invalid(
-                "This board is unknown, please set the family manually. "
+                "This board is unknown, if you are sure you want to compile with this board selection, "
-                "Also, make sure the chosen chip component is correct.",
+                f"override with option '{CONF_FAMILY}'",
                 path=[CONF_BOARD],
             )
+        _LOGGER.warning(
+            "This board is unknown. Make sure the chosen chip component is correct.",
+        )
+    else:
+        family = component.boards[board][KEY_FAMILY]
+        if CONF_FAMILY in value and family != value[CONF_FAMILY]:
+            raise cv.Invalid(
+                f"Option '{CONF_FAMILY}' does not match selected board.",
+                path=[CONF_FAMILY],
+            )
         value = value.copy()
-        value[CONF_FAMILY] = component.boards[board][KEY_FAMILY]
+        value[CONF_FAMILY] = family
     # read component name matching this family
     value[CONF_COMPONENT_ID] = FAMILY_COMPONENT[value[CONF_FAMILY]]
     # make sure the chosen component matches the family
@@ -72,11 +86,6 @@ def _detect_variant(value):
             f"The chosen family doesn't belong to '{component.name}' component. The correct component is '{value[CONF_COMPONENT_ID]}'",
             path=[CONF_FAMILY],
         )
-    # warn anyway if the board wasn't found
-    if board not in component.boards:
-        _LOGGER.warning(
-            "This board is unknown. Make sure the chosen chip component is correct.",
-        )
     return value
 
 

esphome/components/light/__init__.py

@@ -137,18 +137,16 @@ async def setup_light_core_(light_var, output_var, config):
 
     cg.add(light_var.set_restore_mode(config[CONF_RESTORE_MODE]))
 
-    if CONF_DEFAULT_TRANSITION_LENGTH in config:
+    if (
-        cg.add(
+        default_transition_length := config.get(CONF_DEFAULT_TRANSITION_LENGTH)
-            light_var.set_default_transition_length(
+    ) is not None:
-                config[CONF_DEFAULT_TRANSITION_LENGTH]
+        cg.add(light_var.set_default_transition_length(default_transition_length))
-            )
+    if (
-        )
+        flash_transition_length := config.get(CONF_FLASH_TRANSITION_LENGTH)
-    if CONF_FLASH_TRANSITION_LENGTH in config:
+    ) is not None:
-        cg.add(
+        cg.add(light_var.set_flash_transition_length(flash_transition_length))
-            light_var.set_flash_transition_length(config[CONF_FLASH_TRANSITION_LENGTH])
+    if (gamma_correct := config.get(CONF_GAMMA_CORRECT)) is not None:
-        )
+        cg.add(light_var.set_gamma_correct(gamma_correct))
-    if CONF_GAMMA_CORRECT in config:
-        cg.add(light_var.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
     effects = await cg.build_registry_list(
         EFFECTS_REGISTRY, config.get(CONF_EFFECTS, [])
     )
@@ -164,15 +162,15 @@ async def setup_light_core_(light_var, output_var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], light_var)
         await auto.build_automation(trigger, [], conf)
 
-    if CONF_COLOR_CORRECT in config:
+    if (color_correct := config.get(CONF_COLOR_CORRECT)) is not None:
-        cg.add(output_var.set_correction(*config[CONF_COLOR_CORRECT]))
+        cg.add(output_var.set_correction(*color_correct))
 
-    if CONF_POWER_SUPPLY in config:
+    if (power_supply_id := config.get(CONF_POWER_SUPPLY)) is not None:
-        var_ = await cg.get_variable(config[CONF_POWER_SUPPLY])
+        var_ = await cg.get_variable(power_supply_id)
         cg.add(output_var.set_power_supply(var_))
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], light_var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, light_var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
 

esphome/components/light/light_call.cpp

@@ -337,9 +337,12 @@ LightColorValues LightCall::validate_() {
 void LightCall::transform_parameters_() {
   auto traits = this->parent_->get_traits();
 
-  // Allow CWWW modes to be set with a white value and/or color temperature. This is used by HA,
+  // Allow CWWW modes to be set with a white value and/or color temperature.
-  // which doesn't support CWWW modes (yet?), and for compatibility with the pre-colormode model,
+  // This is used in three cases in HA:
-  // as CWWW and RGBWW lights used to represent their values as white + color temperature.
+  // - CW/WW lights, which set the "brightness" and "color_temperature"
+  // - RGBWW lights with color_interlock=true, which also sets "brightness" and
+  //   "color_temperature" (without color_interlock, CW/WW are set directly)
+  // - Legacy Home Assistant (pre-colormode), which sets "white" and "color_temperature"
   if (((this->white_.has_value() && *this->white_ > 0.0f) || this->color_temperature_.has_value()) &&  //
       (*this->color_mode_ & ColorCapability::COLD_WARM_WHITE) &&                                       //
       !(*this->color_mode_ & ColorCapability::WHITE) &&                                                //
@@ -347,21 +350,17 @@ void LightCall::transform_parameters_() {
       traits.get_min_mireds() > 0.0f && traits.get_max_mireds() > 0.0f) {
     ESP_LOGD(TAG, "'%s' - Setting cold/warm white channels using white/color temperature values.",
              this->parent_->get_name().c_str());
-    auto current_values = this->parent_->remote_values;
     if (this->color_temperature_.has_value()) {
-      const float white =
-          this->white_.value_or(fmaxf(current_values.get_cold_white(), current_values.get_warm_white()));
       const float color_temp = clamp(*this->color_temperature_, traits.get_min_mireds(), traits.get_max_mireds());
       const float ww_fraction =
           (color_temp - traits.get_min_mireds()) / (traits.get_max_mireds() - traits.get_min_mireds());
       const float cw_fraction = 1.0f - ww_fraction;
       const float max_cw_ww = std::max(ww_fraction, cw_fraction);
-      this->cold_white_ = white * gamma_uncorrect(cw_fraction / max_cw_ww, this->parent_->get_gamma_correct());
+      this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, this->parent_->get_gamma_correct());
-      this->warm_white_ = white * gamma_uncorrect(ww_fraction / max_cw_ww, this->parent_->get_gamma_correct());
+      this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, this->parent_->get_gamma_correct());
-    } else {
+    }
-      const float max_cw_ww = std::max(current_values.get_warm_white(), current_values.get_cold_white());
+    if (this->white_.has_value()) {
-      this->cold_white_ = *this->white_ * current_values.get_cold_white() / max_cw_ww;
+      this->brightness_ = *this->white_;
-      this->warm_white_ = *this->white_ * current_values.get_warm_white() / max_cw_ww;
     }
   }
 }

esphome/components/light/light_color_values.h

@@ -266,6 +266,21 @@ class LightColorValues {
   /// Set the color temperature property of these light color values in mired.
   void set_color_temperature(float color_temperature) { this->color_temperature_ = color_temperature; }
 
+  /// Get the color temperature property of these light color values in kelvin.
+  float get_color_temperature_kelvin() const {
+    if (this->color_temperature_ <= 0) {
+      return this->color_temperature_;
+    }
+    return 1000000.0 / this->color_temperature_;
+  }
+  /// Set the color temperature property of these light color values in kelvin.
+  void set_color_temperature_kelvin(float color_temperature) {
+    if (color_temperature <= 0) {
+      return;
+    }
+    this->color_temperature_ = 1000000.0 / color_temperature;
+  }
+
   /// Get the cold white property of these light color values. In range 0.0 to 1.0.
   float get_cold_white() const { return this->cold_white_; }
   /// Set the cold white property of these light color values. In range 0.0 to 1.0.

esphome/components/lock/__init__.py

@@ -57,8 +57,8 @@ async def setup_lock_core_(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
-    if CONF_MQTT_ID in config:
+    if mqtt_id := config.get(CONF_MQTT_ID):
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
 

esphome/components/logger/logger_esp32.cpp

@@ -120,30 +120,28 @@ void Logger::pre_setup() {
     switch (this->uart_) {
       case UART_SELECTION_UART0:
         this->uart_num_ = UART_NUM_0;
+        init_uart(this->uart_num_, baud_rate_, tx_buffer_size_);
         break;
       case UART_SELECTION_UART1:
         this->uart_num_ = UART_NUM_1;
+        init_uart(this->uart_num_, baud_rate_, tx_buffer_size_);
         break;
 #ifdef USE_ESP32_VARIANT_ESP32
       case UART_SELECTION_UART2:
         this->uart_num_ = UART_NUM_2;
+        init_uart(this->uart_num_, baud_rate_, tx_buffer_size_);
         break;
 #endif
 #ifdef USE_LOGGER_USB_CDC
       case UART_SELECTION_USB_CDC:
-        this->uart_num_ = -1;
         break;
 #endif
 #ifdef USE_LOGGER_USB_SERIAL_JTAG
       case UART_SELECTION_USB_SERIAL_JTAG:
-        this->uart_num_ = -1;
         init_usb_serial_jtag_();
         break;
 #endif
     }
-    if (this->uart_num_ >= 0) {
-      init_uart(this->uart_num_, baud_rate_, tx_buffer_size_);
-    }
 #endif  // USE_ESP_IDF
   }
 

esphome/components/mqtt/__init__.py

@@ -119,6 +119,8 @@ MQTTTextComponent = mqtt_ns.class_("MQTTTextComponent", MQTTComponent)
 MQTTSelectComponent = mqtt_ns.class_("MQTTSelectComponent", MQTTComponent)
 MQTTButtonComponent = mqtt_ns.class_("MQTTButtonComponent", MQTTComponent)
 MQTTLockComponent = mqtt_ns.class_("MQTTLockComponent", MQTTComponent)
+MQTTEventComponent = mqtt_ns.class_("MQTTEventComponent", MQTTComponent)
+MQTTValveComponent = mqtt_ns.class_("MQTTValveComponent", MQTTComponent)
 
 MQTTDiscoveryUniqueIdGenerator = mqtt_ns.enum("MQTTDiscoveryUniqueIdGenerator")
 MQTT_DISCOVERY_UNIQUE_ID_GENERATOR_OPTIONS = {

esphome/components/mqtt/mqtt_const.h

@@ -9,8 +9,8 @@ namespace mqtt {
 
 #ifdef USE_MQTT_ABBREVIATIONS
 
-constexpr const char *const MQTT_ACTION_TOPIC = "act_t";
 constexpr const char *const MQTT_ACTION_TEMPLATE = "act_tpl";
+constexpr const char *const MQTT_ACTION_TOPIC = "act_t";
 constexpr const char *const MQTT_AUTOMATION_TYPE = "atype";
 constexpr const char *const MQTT_AUX_COMMAND_TOPIC = "aux_cmd_t";
 constexpr const char *const MQTT_AUX_STATE_TEMPLATE = "aux_stat_tpl";
@@ -21,60 +21,70 @@ constexpr const char *const MQTT_AVAILABILITY_TOPIC = "avty_t";
 constexpr const char *const MQTT_AWAY_MODE_COMMAND_TOPIC = "away_mode_cmd_t";
 constexpr const char *const MQTT_AWAY_MODE_STATE_TEMPLATE = "away_mode_stat_tpl";
 constexpr const char *const MQTT_AWAY_MODE_STATE_TOPIC = "away_mode_stat_t";
+constexpr const char *const MQTT_BATTERY_LEVEL_TEMPLATE = "bat_lev_tpl";
+constexpr const char *const MQTT_BATTERY_LEVEL_TOPIC = "bat_lev_t";
 constexpr const char *const MQTT_BLUE_TEMPLATE = "b_tpl";
 constexpr const char *const MQTT_BRIGHTNESS_COMMAND_TOPIC = "bri_cmd_t";
 constexpr const char *const MQTT_BRIGHTNESS_SCALE = "bri_scl";
 constexpr const char *const MQTT_BRIGHTNESS_STATE_TOPIC = "bri_stat_t";
 constexpr const char *const MQTT_BRIGHTNESS_TEMPLATE = "bri_tpl";
 constexpr const char *const MQTT_BRIGHTNESS_VALUE_TEMPLATE = "bri_val_tpl";
-constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TEMPLATE = "clr_temp_cmd_tpl";
-constexpr const char *const MQTT_BATTERY_LEVEL_TOPIC = "bat_lev_t";
-constexpr const char *const MQTT_BATTERY_LEVEL_TEMPLATE = "bat_lev_tpl";
-constexpr const char *const MQTT_CONFIGURATION_URL = "cu";
-constexpr const char *const MQTT_CHARGING_TOPIC = "chrg_t";
 constexpr const char *const MQTT_CHARGING_TEMPLATE = "chrg_tpl";
+constexpr const char *const MQTT_CHARGING_TOPIC = "chrg_t";
+constexpr const char *const MQTT_CLEANING_TEMPLATE = "cln_tpl";
+constexpr const char *const MQTT_CLEANING_TOPIC = "cln_t";
+constexpr const char *const MQTT_CODE_ARM_REQUIRED = "cod_arm_req";
+constexpr const char *const MQTT_CODE_DISARM_REQUIRED = "cod_dis_req";
 constexpr const char *const MQTT_COLOR_MODE = "clrm";
 constexpr const char *const MQTT_COLOR_MODE_STATE_TOPIC = "clrm_stat_t";
 constexpr const char *const MQTT_COLOR_MODE_VALUE_TEMPLATE = "clrm_val_tpl";
+constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TEMPLATE = "clr_temp_cmd_tpl";
 constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TOPIC = "clr_temp_cmd_t";
 constexpr const char *const MQTT_COLOR_TEMP_STATE_TOPIC = "clr_temp_stat_t";
 constexpr const char *const MQTT_COLOR_TEMP_TEMPLATE = "clr_temp_tpl";
 constexpr const char *const MQTT_COLOR_TEMP_VALUE_TEMPLATE = "clr_temp_val_tpl";
-constexpr const char *const MQTT_CLEANING_TOPIC = "cln_t";
-constexpr const char *const MQTT_CLEANING_TEMPLATE = "cln_tpl";
 constexpr const char *const MQTT_COMMAND_OFF_TEMPLATE = "cmd_off_tpl";
 constexpr const char *const MQTT_COMMAND_ON_TEMPLATE = "cmd_on_tpl";
-constexpr const char *const MQTT_COMMAND_TOPIC = "cmd_t";
 constexpr const char *const MQTT_COMMAND_RETAIN = "ret";
 constexpr const char *const MQTT_COMMAND_TEMPLATE = "cmd_tpl";
-constexpr const char *const MQTT_CODE_ARM_REQUIRED = "cod_arm_req";
+constexpr const char *const MQTT_COMMAND_TOPIC = "cmd_t";
-constexpr const char *const MQTT_CODE_DISARM_REQUIRED = "cod_dis_req";
+constexpr const char *const MQTT_CONFIGURATION_URL = "cu";
-constexpr const char *const MQTT_CURRENT_TEMPERATURE_TOPIC = "curr_temp_t";
-constexpr const char *const MQTT_CURRENT_TEMPERATURE_TEMPLATE = "curr_temp_tpl";
-constexpr const char *const MQTT_CURRENT_HUMIDITY_TOPIC = "curr_hum_t";
 constexpr const char *const MQTT_CURRENT_HUMIDITY_TEMPLATE = "curr_hum_tpl";
+constexpr const char *const MQTT_CURRENT_HUMIDITY_TOPIC = "curr_hum_t";
+constexpr const char *const MQTT_CURRENT_TEMPERATURE_TEMPLATE = "curr_temp_tpl";
+constexpr const char *const MQTT_CURRENT_TEMPERATURE_TOPIC = "curr_temp_t";
 constexpr const char *const MQTT_DEVICE = "dev";
 constexpr const char *const MQTT_DEVICE_CLASS = "dev_cla";
-constexpr const char *const MQTT_DOCKED_TOPIC = "dock_t";
+constexpr const char *const MQTT_DEVICE_CONNECTIONS = "cns";
+constexpr const char *const MQTT_DEVICE_IDENTIFIERS = "ids";
+constexpr const char *const MQTT_DEVICE_MANUFACTURER = "mf";
+constexpr const char *const MQTT_DEVICE_MODEL = "mdl";
+constexpr const char *const MQTT_DEVICE_NAME = "name";
+constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "sa";
+constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw";
 constexpr const char *const MQTT_DOCKED_TEMPLATE = "dock_tpl";
-constexpr const char *const MQTT_ENABLED_BY_DEFAULT = "en";
+constexpr const char *const MQTT_DOCKED_TOPIC = "dock_t";
-constexpr const char *const MQTT_ERROR_TOPIC = "err_t";
-constexpr const char *const MQTT_ERROR_TEMPLATE = "err_tpl";
-constexpr const char *const MQTT_FAN_SPEED_TOPIC = "fanspd_t";
-constexpr const char *const MQTT_FAN_SPEED_TEMPLATE = "fanspd_tpl";
-constexpr const char *const MQTT_FAN_SPEED_LIST = "fanspd_lst";
-constexpr const char *const MQTT_FLASH_TIME_LONG = "flsh_tlng";
-constexpr const char *const MQTT_FLASH_TIME_SHORT = "flsh_tsht";
 constexpr const char *const MQTT_EFFECT_COMMAND_TOPIC = "fx_cmd_t";
 constexpr const char *const MQTT_EFFECT_LIST = "fx_list";
 constexpr const char *const MQTT_EFFECT_STATE_TOPIC = "fx_stat_t";
 constexpr const char *const MQTT_EFFECT_TEMPLATE = "fx_tpl";
 constexpr const char *const MQTT_EFFECT_VALUE_TEMPLATE = "fx_val_tpl";
+constexpr const char *const MQTT_ENABLED_BY_DEFAULT = "en";
+constexpr const char *const MQTT_ENTITY_CATEGORY = "ent_cat";
+constexpr const char *const MQTT_ERROR_TEMPLATE = "err_tpl";
+constexpr const char *const MQTT_ERROR_TOPIC = "err_t";
+constexpr const char *const MQTT_EVENT_TYPE = "event_type";
+constexpr const char *const MQTT_EVENT_TYPES = "evt_typ";
 constexpr const char *const MQTT_EXPIRE_AFTER = "exp_aft";
 constexpr const char *const MQTT_FAN_MODE_COMMAND_TEMPLATE = "fan_mode_cmd_tpl";
 constexpr const char *const MQTT_FAN_MODE_COMMAND_TOPIC = "fan_mode_cmd_t";
 constexpr const char *const MQTT_FAN_MODE_STATE_TEMPLATE = "fan_mode_stat_tpl";
 constexpr const char *const MQTT_FAN_MODE_STATE_TOPIC = "fan_mode_stat_t";
+constexpr const char *const MQTT_FAN_SPEED_LIST = "fanspd_lst";
+constexpr const char *const MQTT_FAN_SPEED_TEMPLATE = "fanspd_tpl";
+constexpr const char *const MQTT_FAN_SPEED_TOPIC = "fanspd_t";
+constexpr const char *const MQTT_FLASH_TIME_LONG = "flsh_tlng";
+constexpr const char *const MQTT_FLASH_TIME_SHORT = "flsh_tsht";
 constexpr const char *const MQTT_FORCE_UPDATE = "frc_upd";
 constexpr const char *const MQTT_GREEN_TEMPLATE = "g_tpl";
 constexpr const char *const MQTT_HOLD_COMMAND_TEMPLATE = "hold_cmd_tpl";
@@ -86,56 +96,49 @@ constexpr const char *const MQTT_HS_STATE_TOPIC = "hs_stat_t";
 constexpr const char *const MQTT_HS_VALUE_TEMPLATE = "hs_val_tpl";
 constexpr const char *const MQTT_ICON = "ic";
 constexpr const char *const MQTT_INITIAL = "init";
-constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TOPIC = "hum_cmd_t";
-constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TEMPLATE = "hum_cmd_tpl";
-constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TOPIC = "hum_stat_t";
-constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TEMPLATE = "hum_state_tpl";
 constexpr const char *const MQTT_JSON_ATTRIBUTES = "json_attr";
-constexpr const char *const MQTT_JSON_ATTRIBUTES_TOPIC = "json_attr_t";
 constexpr const char *const MQTT_JSON_ATTRIBUTES_TEMPLATE = "json_attr_tpl";
+constexpr const char *const MQTT_JSON_ATTRIBUTES_TOPIC = "json_attr_t";
 constexpr const char *const MQTT_LAST_RESET_TOPIC = "lrst_t";
 constexpr const char *const MQTT_LAST_RESET_VALUE_TEMPLATE = "lrst_val_tpl";
 constexpr const char *const MQTT_MAX = "max";
-constexpr const char *const MQTT_MIN = "min";
 constexpr const char *const MQTT_MAX_HUMIDITY = "max_hum";
-constexpr const char *const MQTT_MIN_HUMIDITY = "min_hum";
 constexpr const char *const MQTT_MAX_MIREDS = "max_mirs";
-constexpr const char *const MQTT_MIN_MIREDS = "min_mirs";
 constexpr const char *const MQTT_MAX_TEMP = "max_temp";
+constexpr const char *const MQTT_MIN = "min";
+constexpr const char *const MQTT_MIN_HUMIDITY = "min_hum";
+constexpr const char *const MQTT_MIN_MIREDS = "min_mirs";
 constexpr const char *const MQTT_MIN_TEMP = "min_temp";
+constexpr const char *const MQTT_MODE = "mode";
 constexpr const char *const MQTT_MODE_COMMAND_TEMPLATE = "mode_cmd_tpl";
 constexpr const char *const MQTT_MODE_COMMAND_TOPIC = "mode_cmd_t";
-constexpr const char *const MQTT_MODE_STATE_TOPIC = "mode_stat_t";
 constexpr const char *const MQTT_MODE_STATE_TEMPLATE = "mode_stat_tpl";
+constexpr const char *const MQTT_MODE_STATE_TOPIC = "mode_stat_t";
 constexpr const char *const MQTT_MODES = "modes";
 constexpr const char *const MQTT_NAME = "name";
 constexpr const char *const MQTT_OBJECT_ID = "obj_id";
 constexpr const char *const MQTT_OFF_DELAY = "off_dly";
 constexpr const char *const MQTT_ON_COMMAND_TYPE = "on_cmd_type";
-constexpr const char *const MQTT_OPTIONS = "ops";
 constexpr const char *const MQTT_OPTIMISTIC = "opt";
-constexpr const char *const MQTT_OSCILLATION_COMMAND_TOPIC = "osc_cmd_t";
+constexpr const char *const MQTT_OPTIONS = "ops";
 constexpr const char *const MQTT_OSCILLATION_COMMAND_TEMPLATE = "osc_cmd_tpl";
+constexpr const char *const MQTT_OSCILLATION_COMMAND_TOPIC = "osc_cmd_t";
 constexpr const char *const MQTT_OSCILLATION_STATE_TOPIC = "osc_stat_t";
 constexpr const char *const MQTT_OSCILLATION_VALUE_TEMPLATE = "osc_val_tpl";
-constexpr const char *const MQTT_PERCENTAGE_COMMAND_TOPIC = "pct_cmd_t";
-constexpr const char *const MQTT_PERCENTAGE_COMMAND_TEMPLATE = "pct_cmd_tpl";
-constexpr const char *const MQTT_PERCENTAGE_STATE_TOPIC = "pct_stat_t";
-constexpr const char *const MQTT_PERCENTAGE_VALUE_TEMPLATE = "pct_val_tpl";
 constexpr const char *const MQTT_PAYLOAD = "pl";
 constexpr const char *const MQTT_PAYLOAD_ARM_AWAY = "pl_arm_away";
+constexpr const char *const MQTT_PAYLOAD_ARM_CUSTOM_BYPASS = "pl_arm_custom_b";
 constexpr const char *const MQTT_PAYLOAD_ARM_HOME = "pl_arm_home";
 constexpr const char *const MQTT_PAYLOAD_ARM_NIGHT = "pl_arm_nite";
 constexpr const char *const MQTT_PAYLOAD_ARM_VACATION = "pl_arm_vacation";
-constexpr const char *const MQTT_PAYLOAD_ARM_CUSTOM_BYPASS = "pl_arm_custom_b";
 constexpr const char *const MQTT_PAYLOAD_AVAILABLE = "pl_avail";
 constexpr const char *const MQTT_PAYLOAD_CLEAN_SPOT = "pl_cln_sp";
 constexpr const char *const MQTT_PAYLOAD_CLOSE = "pl_cls";
 constexpr const char *const MQTT_PAYLOAD_DISARM = "pl_disarm";
 constexpr const char *const MQTT_PAYLOAD_HIGH_SPEED = "pl_hi_spd";
 constexpr const char *const MQTT_PAYLOAD_HOME = "pl_home";
-constexpr const char *const MQTT_PAYLOAD_LOCK = "pl_lock";
 constexpr const char *const MQTT_PAYLOAD_LOCATE = "pl_loc";
+constexpr const char *const MQTT_PAYLOAD_LOCK = "pl_lock";
 constexpr const char *const MQTT_PAYLOAD_LOW_SPEED = "pl_lo_spd";
 constexpr const char *const MQTT_PAYLOAD_MEDIUM_SPEED = "pl_med_spd";
 constexpr const char *const MQTT_PAYLOAD_NOT_AVAILABLE = "pl_not_avail";
@@ -152,20 +155,26 @@ constexpr const char *const MQTT_PAYLOAD_RESET_HUMIDITY = "pl_rst_hum";
 constexpr const char *const MQTT_PAYLOAD_RESET_MODE = "pl_rst_mode";
 constexpr const char *const MQTT_PAYLOAD_RESET_PERCENTAGE = "pl_rst_pct";
 constexpr const char *const MQTT_PAYLOAD_RESET_PRESET_MODE = "pl_rst_pr_mode";
-constexpr const char *const MQTT_PAYLOAD_STOP = "pl_stop";
+constexpr const char *const MQTT_PAYLOAD_RETURN_TO_BASE = "pl_ret";
 constexpr const char *const MQTT_PAYLOAD_START = "pl_strt";
 constexpr const char *const MQTT_PAYLOAD_START_PAUSE = "pl_stpa";
-constexpr const char *const MQTT_PAYLOAD_RETURN_TO_BASE = "pl_ret";
+constexpr const char *const MQTT_PAYLOAD_STOP = "pl_stop";
 constexpr const char *const MQTT_PAYLOAD_TURN_OFF = "pl_toff";
 constexpr const char *const MQTT_PAYLOAD_TURN_ON = "pl_ton";
 constexpr const char *const MQTT_PAYLOAD_UNLOCK = "pl_unlk";
+constexpr const char *const MQTT_PERCENTAGE_COMMAND_TEMPLATE = "pct_cmd_tpl";
+constexpr const char *const MQTT_PERCENTAGE_COMMAND_TOPIC = "pct_cmd_t";
+constexpr const char *const MQTT_PERCENTAGE_STATE_TOPIC = "pct_stat_t";
+constexpr const char *const MQTT_PERCENTAGE_VALUE_TEMPLATE = "pct_val_tpl";
 constexpr const char *const MQTT_POSITION_CLOSED = "pos_clsd";
 constexpr const char *const MQTT_POSITION_OPEN = "pos_open";
+constexpr const char *const MQTT_POSITION_TEMPLATE = "pos_tpl";
+constexpr const char *const MQTT_POSITION_TOPIC = "pos_t";
 constexpr const char *const MQTT_POWER_COMMAND_TOPIC = "pow_cmd_t";
-constexpr const char *const MQTT_POWER_STATE_TOPIC = "pow_stat_t";
 constexpr const char *const MQTT_POWER_STATE_TEMPLATE = "pow_stat_tpl";
-constexpr const char *const MQTT_PRESET_MODE_COMMAND_TOPIC = "pr_mode_cmd_t";
+constexpr const char *const MQTT_POWER_STATE_TOPIC = "pow_stat_t";
 constexpr const char *const MQTT_PRESET_MODE_COMMAND_TEMPLATE = "pr_mode_cmd_tpl";
+constexpr const char *const MQTT_PRESET_MODE_COMMAND_TOPIC = "pr_mode_cmd_t";
 constexpr const char *const MQTT_PRESET_MODE_STATE_TOPIC = "pr_mode_stat_t";
 constexpr const char *const MQTT_PRESET_MODE_VALUE_TEMPLATE = "pr_mode_val_tpl";
 constexpr const char *const MQTT_PRESET_MODES = "pr_modes";
@@ -188,36 +197,38 @@ constexpr const char *const MQTT_SEND_IF_OFF = "send_if_off";
 constexpr const char *const MQTT_SET_FAN_SPEED_TOPIC = "set_fan_spd_t";
 constexpr const char *const MQTT_SET_POSITION_TEMPLATE = "set_pos_tpl";
 constexpr const char *const MQTT_SET_POSITION_TOPIC = "set_pos_t";
-constexpr const char *const MQTT_POSITION_TOPIC = "pos_t";
+constexpr const char *const MQTT_SOURCE_TYPE = "src_type";
-constexpr const char *const MQTT_POSITION_TEMPLATE = "pos_tpl";
 constexpr const char *const MQTT_SPEED_COMMAND_TOPIC = "spd_cmd_t";
-constexpr const char *const MQTT_SPEED_STATE_TOPIC = "spd_stat_t";
-constexpr const char *const MQTT_SPEED_RANGE_MIN = "spd_rng_min";
 constexpr const char *const MQTT_SPEED_RANGE_MAX = "spd_rng_max";
+constexpr const char *const MQTT_SPEED_RANGE_MIN = "spd_rng_min";
+constexpr const char *const MQTT_SPEED_STATE_TOPIC = "spd_stat_t";
 constexpr const char *const MQTT_SPEED_VALUE_TEMPLATE = "spd_val_tpl";
 constexpr const char *const MQTT_SPEEDS = "spds";
-constexpr const char *const MQTT_SOURCE_TYPE = "src_type";
 constexpr const char *const MQTT_STATE_CLASS = "stat_cla";
 constexpr const char *const MQTT_STATE_CLOSED = "stat_clsd";
 constexpr const char *const MQTT_STATE_CLOSING = "stat_closing";
+constexpr const char *const MQTT_STATE_LOCKED = "stat_locked";
 constexpr const char *const MQTT_STATE_OFF = "stat_off";
 constexpr const char *const MQTT_STATE_ON = "stat_on";
 constexpr const char *const MQTT_STATE_OPEN = "stat_open";
 constexpr const char *const MQTT_STATE_OPENING = "stat_opening";
 constexpr const char *const MQTT_STATE_STOPPED = "stat_stopped";
-constexpr const char *const MQTT_STATE_LOCKED = "stat_locked";
-constexpr const char *const MQTT_STATE_UNLOCKED = "stat_unlocked";
-constexpr const char *const MQTT_STATE_TOPIC = "stat_t";
 constexpr const char *const MQTT_STATE_TEMPLATE = "stat_tpl";
+constexpr const char *const MQTT_STATE_TOPIC = "stat_t";
+constexpr const char *const MQTT_STATE_UNLOCKED = "stat_unlocked";
 constexpr const char *const MQTT_STATE_VALUE_TEMPLATE = "stat_val_tpl";
 constexpr const char *const MQTT_STEP = "step";
 constexpr const char *const MQTT_SUBTYPE = "stype";
-constexpr const char *const MQTT_SUPPORTED_FEATURES = "sup_feat";
 constexpr const char *const MQTT_SUPPORTED_COLOR_MODES = "sup_clrm";
+constexpr const char *const MQTT_SUPPORTED_FEATURES = "sup_feat";
 constexpr const char *const MQTT_SWING_MODE_COMMAND_TEMPLATE = "swing_mode_cmd_tpl";
 constexpr const char *const MQTT_SWING_MODE_COMMAND_TOPIC = "swing_mode_cmd_t";
 constexpr const char *const MQTT_SWING_MODE_STATE_TEMPLATE = "swing_mode_stat_tpl";
 constexpr const char *const MQTT_SWING_MODE_STATE_TOPIC = "swing_mode_stat_t";
+constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TEMPLATE = "hum_cmd_tpl";
+constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TOPIC = "hum_cmd_t";
+constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TEMPLATE = "hum_state_tpl";
+constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TOPIC = "hum_stat_t";
 constexpr const char *const MQTT_TEMPERATURE_COMMAND_TEMPLATE = "temp_cmd_tpl";
 constexpr const char *const MQTT_TEMPERATURE_COMMAND_TOPIC = "temp_cmd_t";
 constexpr const char *const MQTT_TEMPERATURE_HIGH_COMMAND_TEMPLATE = "temp_hi_cmd_tpl";
@@ -232,15 +243,15 @@ constexpr const char *const MQTT_TEMPERATURE_STATE_TEMPLATE = "temp_stat_tpl";
 constexpr const char *const MQTT_TEMPERATURE_STATE_TOPIC = "temp_stat_t";
 constexpr const char *const MQTT_TEMPERATURE_UNIT = "temp_unit";
 constexpr const char *const MQTT_TILT_CLOSED_VALUE = "tilt_clsd_val";
-constexpr const char *const MQTT_TILT_COMMAND_TOPIC = "tilt_cmd_t";
 constexpr const char *const MQTT_TILT_COMMAND_TEMPLATE = "tilt_cmd_tpl";
+constexpr const char *const MQTT_TILT_COMMAND_TOPIC = "tilt_cmd_t";
 constexpr const char *const MQTT_TILT_INVERT_STATE = "tilt_inv_stat";
 constexpr const char *const MQTT_TILT_MAX = "tilt_max";
 constexpr const char *const MQTT_TILT_MIN = "tilt_min";
 constexpr const char *const MQTT_TILT_OPENED_VALUE = "tilt_opnd_val";
 constexpr const char *const MQTT_TILT_OPTIMISTIC = "tilt_opt";
-constexpr const char *const MQTT_TILT_STATUS_TOPIC = "tilt_status_t";
 constexpr const char *const MQTT_TILT_STATUS_TEMPLATE = "tilt_status_tpl";
+constexpr const char *const MQTT_TILT_STATUS_TOPIC = "tilt_status_t";
 constexpr const char *const MQTT_TOPIC = "t";
 constexpr const char *const MQTT_UNIQUE_ID = "uniq_id";
 constexpr const char *const MQTT_UNIT_OF_MEASUREMENT = "unit_of_meas";
@@ -255,18 +266,10 @@ constexpr const char *const MQTT_XY_COMMAND_TOPIC = "xy_cmd_t";
 constexpr const char *const MQTT_XY_STATE_TOPIC = "xy_stat_t";
 constexpr const char *const MQTT_XY_VALUE_TEMPLATE = "xy_val_tpl";
 
-constexpr const char *const MQTT_DEVICE_CONNECTIONS = "cns";
-constexpr const char *const MQTT_DEVICE_IDENTIFIERS = "ids";
-constexpr const char *const MQTT_DEVICE_NAME = "name";
-constexpr const char *const MQTT_DEVICE_MANUFACTURER = "mf";
-constexpr const char *const MQTT_DEVICE_MODEL = "mdl";
-constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw";
-constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "sa";
-
 #else
 
-constexpr const char *const MQTT_ACTION_TOPIC = "action_topic";
 constexpr const char *const MQTT_ACTION_TEMPLATE = "action_template";
+constexpr const char *const MQTT_ACTION_TOPIC = "action_topic";
 constexpr const char *const MQTT_AUTOMATION_TYPE = "automation_type";
 constexpr const char *const MQTT_AUX_COMMAND_TOPIC = "aux_command_topic";
 constexpr const char *const MQTT_AUX_STATE_TEMPLATE = "aux_state_template";
@@ -277,60 +280,70 @@ constexpr const char *const MQTT_AVAILABILITY_TOPIC = "availability_topic";
 constexpr const char *const MQTT_AWAY_MODE_COMMAND_TOPIC = "away_mode_command_topic";
 constexpr const char *const MQTT_AWAY_MODE_STATE_TEMPLATE = "away_mode_state_template";
 constexpr const char *const MQTT_AWAY_MODE_STATE_TOPIC = "away_mode_state_topic";
+constexpr const char *const MQTT_BATTERY_LEVEL_TEMPLATE = "battery_level_template";
+constexpr const char *const MQTT_BATTERY_LEVEL_TOPIC = "battery_level_topic";
 constexpr const char *const MQTT_BLUE_TEMPLATE = "blue_template";
 constexpr const char *const MQTT_BRIGHTNESS_COMMAND_TOPIC = "brightness_command_topic";
 constexpr const char *const MQTT_BRIGHTNESS_SCALE = "brightness_scale";
 constexpr const char *const MQTT_BRIGHTNESS_STATE_TOPIC = "brightness_state_topic";
 constexpr const char *const MQTT_BRIGHTNESS_TEMPLATE = "brightness_template";
 constexpr const char *const MQTT_BRIGHTNESS_VALUE_TEMPLATE = "brightness_value_template";
-constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TEMPLATE = "color_temp_command_template";
-constexpr const char *const MQTT_BATTERY_LEVEL_TOPIC = "battery_level_topic";
-constexpr const char *const MQTT_BATTERY_LEVEL_TEMPLATE = "battery_level_template";
-constexpr const char *const MQTT_CONFIGURATION_URL = "configuration_url";
-constexpr const char *const MQTT_CHARGING_TOPIC = "charging_topic";
 constexpr const char *const MQTT_CHARGING_TEMPLATE = "charging_template";
+constexpr const char *const MQTT_CHARGING_TOPIC = "charging_topic";
+constexpr const char *const MQTT_CLEANING_TEMPLATE = "cleaning_template";
+constexpr const char *const MQTT_CLEANING_TOPIC = "cleaning_topic";
+constexpr const char *const MQTT_CODE_ARM_REQUIRED = "code_arm_required";
+constexpr const char *const MQTT_CODE_DISARM_REQUIRED = "code_disarm_required";
 constexpr const char *const MQTT_COLOR_MODE = "color_mode";
 constexpr const char *const MQTT_COLOR_MODE_STATE_TOPIC = "color_mode_state_topic";
 constexpr const char *const MQTT_COLOR_MODE_VALUE_TEMPLATE = "color_mode_value_template";
+constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TEMPLATE = "color_temp_command_template";
 constexpr const char *const MQTT_COLOR_TEMP_COMMAND_TOPIC = "color_temp_command_topic";
 constexpr const char *const MQTT_COLOR_TEMP_STATE_TOPIC = "color_temp_state_topic";
 constexpr const char *const MQTT_COLOR_TEMP_TEMPLATE = "color_temp_template";
 constexpr const char *const MQTT_COLOR_TEMP_VALUE_TEMPLATE = "color_temp_value_template";
-constexpr const char *const MQTT_CLEANING_TOPIC = "cleaning_topic";
-constexpr const char *const MQTT_CLEANING_TEMPLATE = "cleaning_template";
 constexpr const char *const MQTT_COMMAND_OFF_TEMPLATE = "command_off_template";
 constexpr const char *const MQTT_COMMAND_ON_TEMPLATE = "command_on_template";
-constexpr const char *const MQTT_COMMAND_TOPIC = "command_topic";
 constexpr const char *const MQTT_COMMAND_RETAIN = "retain";
 constexpr const char *const MQTT_COMMAND_TEMPLATE = "command_template";
-constexpr const char *const MQTT_CODE_ARM_REQUIRED = "code_arm_required";
+constexpr const char *const MQTT_COMMAND_TOPIC = "command_topic";
-constexpr const char *const MQTT_CODE_DISARM_REQUIRED = "code_disarm_required";
+constexpr const char *const MQTT_CONFIGURATION_URL = "configuration_url";
-constexpr const char *const MQTT_CURRENT_TEMPERATURE_TOPIC = "current_temperature_topic";
-constexpr const char *const MQTT_CURRENT_TEMPERATURE_TEMPLATE = "current_temperature_template";
-constexpr const char *const MQTT_CURRENT_HUMIDITY_TOPIC = "current_humidity_topic";
 constexpr const char *const MQTT_CURRENT_HUMIDITY_TEMPLATE = "current_humidity_template";
+constexpr const char *const MQTT_CURRENT_HUMIDITY_TOPIC = "current_humidity_topic";
+constexpr const char *const MQTT_CURRENT_TEMPERATURE_TEMPLATE = "current_temperature_template";
+constexpr const char *const MQTT_CURRENT_TEMPERATURE_TOPIC = "current_temperature_topic";
 constexpr const char *const MQTT_DEVICE = "device";
 constexpr const char *const MQTT_DEVICE_CLASS = "device_class";
-constexpr const char *const MQTT_DOCKED_TOPIC = "docked_topic";
+constexpr const char *const MQTT_DEVICE_CONNECTIONS = "connections";
+constexpr const char *const MQTT_DEVICE_IDENTIFIERS = "identifiers";
+constexpr const char *const MQTT_DEVICE_MANUFACTURER = "manufacturer";
+constexpr const char *const MQTT_DEVICE_MODEL = "model";
+constexpr const char *const MQTT_DEVICE_NAME = "name";
+constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "suggested_area";
+constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw_version";
 constexpr const char *const MQTT_DOCKED_TEMPLATE = "docked_template";
-constexpr const char *const MQTT_ENABLED_BY_DEFAULT = "enabled_by_default";
+constexpr const char *const MQTT_DOCKED_TOPIC = "docked_topic";
-constexpr const char *const MQTT_ERROR_TOPIC = "error_topic";
-constexpr const char *const MQTT_ERROR_TEMPLATE = "error_template";
-constexpr const char *const MQTT_FAN_SPEED_TOPIC = "fan_speed_topic";
-constexpr const char *const MQTT_FAN_SPEED_TEMPLATE = "fan_speed_template";
-constexpr const char *const MQTT_FAN_SPEED_LIST = "fan_speed_list";
-constexpr const char *const MQTT_FLASH_TIME_LONG = "flash_time_long";
-constexpr const char *const MQTT_FLASH_TIME_SHORT = "flash_time_short";
 constexpr const char *const MQTT_EFFECT_COMMAND_TOPIC = "effect_command_topic";
 constexpr const char *const MQTT_EFFECT_LIST = "effect_list";
 constexpr const char *const MQTT_EFFECT_STATE_TOPIC = "effect_state_topic";
 constexpr const char *const MQTT_EFFECT_TEMPLATE = "effect_template";
 constexpr const char *const MQTT_EFFECT_VALUE_TEMPLATE = "effect_value_template";
+constexpr const char *const MQTT_ENABLED_BY_DEFAULT = "enabled_by_default";
+constexpr const char *const MQTT_ENTITY_CATEGORY = "entity_category";
+constexpr const char *const MQTT_ERROR_TEMPLATE = "error_template";
+constexpr const char *const MQTT_ERROR_TOPIC = "error_topic";
+constexpr const char *const MQTT_EVENT_TYPE = "event_type";
+constexpr const char *const MQTT_EVENT_TYPES = "event_types";
 constexpr const char *const MQTT_EXPIRE_AFTER = "expire_after";
 constexpr const char *const MQTT_FAN_MODE_COMMAND_TEMPLATE = "fan_mode_command_template";
 constexpr const char *const MQTT_FAN_MODE_COMMAND_TOPIC = "fan_mode_command_topic";
 constexpr const char *const MQTT_FAN_MODE_STATE_TEMPLATE = "fan_mode_state_template";
 constexpr const char *const MQTT_FAN_MODE_STATE_TOPIC = "fan_mode_state_topic";
+constexpr const char *const MQTT_FAN_SPEED_LIST = "fan_speed_list";
+constexpr const char *const MQTT_FAN_SPEED_TEMPLATE = "fan_speed_template";
+constexpr const char *const MQTT_FAN_SPEED_TOPIC = "fan_speed_topic";
+constexpr const char *const MQTT_FLASH_TIME_LONG = "flash_time_long";
+constexpr const char *const MQTT_FLASH_TIME_SHORT = "flash_time_short";
 constexpr const char *const MQTT_FORCE_UPDATE = "force_update";
 constexpr const char *const MQTT_GREEN_TEMPLATE = "green_template";
 constexpr const char *const MQTT_HOLD_COMMAND_TEMPLATE = "hold_command_template";
@@ -342,56 +355,49 @@ constexpr const char *const MQTT_HS_STATE_TOPIC = "hs_state_topic";
 constexpr const char *const MQTT_HS_VALUE_TEMPLATE = "hs_value_template";
 constexpr const char *const MQTT_ICON = "icon";
 constexpr const char *const MQTT_INITIAL = "initial";
-constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TOPIC = "target_humidity_command_topic";
-constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TEMPLATE = "target_humidity_command_template";
-constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TOPIC = "target_humidity_state_topic";
-constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TEMPLATE = "target_humidity_state_template";
 constexpr const char *const MQTT_JSON_ATTRIBUTES = "json_attributes";
-constexpr const char *const MQTT_JSON_ATTRIBUTES_TOPIC = "json_attributes_topic";
 constexpr const char *const MQTT_JSON_ATTRIBUTES_TEMPLATE = "json_attributes_template";
+constexpr const char *const MQTT_JSON_ATTRIBUTES_TOPIC = "json_attributes_topic";
 constexpr const char *const MQTT_LAST_RESET_TOPIC = "last_reset_topic";
 constexpr const char *const MQTT_LAST_RESET_VALUE_TEMPLATE = "last_reset_value_template";
 constexpr const char *const MQTT_MAX = "max";
-constexpr const char *const MQTT_MIN = "min";
 constexpr const char *const MQTT_MAX_HUMIDITY = "max_humidity";
-constexpr const char *const MQTT_MIN_HUMIDITY = "min_humidity";
 constexpr const char *const MQTT_MAX_MIREDS = "max_mireds";
-constexpr const char *const MQTT_MIN_MIREDS = "min_mireds";
 constexpr const char *const MQTT_MAX_TEMP = "max_temp";
+constexpr const char *const MQTT_MIN = "min";
+constexpr const char *const MQTT_MIN_HUMIDITY = "min_humidity";
+constexpr const char *const MQTT_MIN_MIREDS = "min_mireds";
 constexpr const char *const MQTT_MIN_TEMP = "min_temp";
+constexpr const char *const MQTT_MODE = "mode";
 constexpr const char *const MQTT_MODE_COMMAND_TEMPLATE = "mode_command_template";
 constexpr const char *const MQTT_MODE_COMMAND_TOPIC = "mode_command_topic";
-constexpr const char *const MQTT_MODE_STATE_TOPIC = "mode_state_topic";
 constexpr const char *const MQTT_MODE_STATE_TEMPLATE = "mode_state_template";
+constexpr const char *const MQTT_MODE_STATE_TOPIC = "mode_state_topic";
 constexpr const char *const MQTT_MODES = "modes";
 constexpr const char *const MQTT_NAME = "name";
 constexpr const char *const MQTT_OBJECT_ID = "object_id";
 constexpr const char *const MQTT_OFF_DELAY = "off_delay";
 constexpr const char *const MQTT_ON_COMMAND_TYPE = "on_command_type";
-constexpr const char *const MQTT_OPTIONS = "options";
 constexpr const char *const MQTT_OPTIMISTIC = "optimistic";
-constexpr const char *const MQTT_OSCILLATION_COMMAND_TOPIC = "oscillation_command_topic";
+constexpr const char *const MQTT_OPTIONS = "options";
 constexpr const char *const MQTT_OSCILLATION_COMMAND_TEMPLATE = "oscillation_command_template";
+constexpr const char *const MQTT_OSCILLATION_COMMAND_TOPIC = "oscillation_command_topic";
 constexpr const char *const MQTT_OSCILLATION_STATE_TOPIC = "oscillation_state_topic";
 constexpr const char *const MQTT_OSCILLATION_VALUE_TEMPLATE = "oscillation_value_template";
-constexpr const char *const MQTT_PERCENTAGE_COMMAND_TOPIC = "percentage_command_topic";
-constexpr const char *const MQTT_PERCENTAGE_COMMAND_TEMPLATE = "percentage_command_template";
-constexpr const char *const MQTT_PERCENTAGE_STATE_TOPIC = "percentage_state_topic";
-constexpr const char *const MQTT_PERCENTAGE_VALUE_TEMPLATE = "percentage_value_template";
 constexpr const char *const MQTT_PAYLOAD = "payload";
 constexpr const char *const MQTT_PAYLOAD_ARM_AWAY = "payload_arm_away";
+constexpr const char *const MQTT_PAYLOAD_ARM_CUSTOM_BYPASS = "payload_arm_custom_bypass";
 constexpr const char *const MQTT_PAYLOAD_ARM_HOME = "payload_arm_home";
 constexpr const char *const MQTT_PAYLOAD_ARM_NIGHT = "payload_arm_night";
 constexpr const char *const MQTT_PAYLOAD_ARM_VACATION = "payload_arm_vacation";
-constexpr const char *const MQTT_PAYLOAD_ARM_CUSTOM_BYPASS = "payload_arm_custom_bypass";
 constexpr const char *const MQTT_PAYLOAD_AVAILABLE = "payload_available";
 constexpr const char *const MQTT_PAYLOAD_CLEAN_SPOT = "payload_clean_spot";
 constexpr const char *const MQTT_PAYLOAD_CLOSE = "payload_close";
 constexpr const char *const MQTT_PAYLOAD_DISARM = "payload_disarm";
 constexpr const char *const MQTT_PAYLOAD_HIGH_SPEED = "payload_high_speed";
 constexpr const char *const MQTT_PAYLOAD_HOME = "payload_home";
-constexpr const char *const MQTT_PAYLOAD_LOCK = "payload_lock";
 constexpr const char *const MQTT_PAYLOAD_LOCATE = "payload_locate";
+constexpr const char *const MQTT_PAYLOAD_LOCK = "payload_lock";
 constexpr const char *const MQTT_PAYLOAD_LOW_SPEED = "payload_low_speed";
 constexpr const char *const MQTT_PAYLOAD_MEDIUM_SPEED = "payload_medium_speed";
 constexpr const char *const MQTT_PAYLOAD_NOT_AVAILABLE = "payload_not_available";
@@ -408,20 +414,26 @@ constexpr const char *const MQTT_PAYLOAD_RESET_HUMIDITY = "payload_reset_humidit
 constexpr const char *const MQTT_PAYLOAD_RESET_MODE = "payload_reset_mode";
 constexpr const char *const MQTT_PAYLOAD_RESET_PERCENTAGE = "payload_reset_percentage";
 constexpr const char *const MQTT_PAYLOAD_RESET_PRESET_MODE = "payload_reset_preset_mode";
-constexpr const char *const MQTT_PAYLOAD_STOP = "payload_stop";
+constexpr const char *const MQTT_PAYLOAD_RETURN_TO_BASE = "payload_return_to_base";
 constexpr const char *const MQTT_PAYLOAD_START = "payload_start";
 constexpr const char *const MQTT_PAYLOAD_START_PAUSE = "payload_start_pause";
-constexpr const char *const MQTT_PAYLOAD_RETURN_TO_BASE = "payload_return_to_base";
+constexpr const char *const MQTT_PAYLOAD_STOP = "payload_stop";
 constexpr const char *const MQTT_PAYLOAD_TURN_OFF = "payload_turn_off";
 constexpr const char *const MQTT_PAYLOAD_TURN_ON = "payload_turn_on";
 constexpr const char *const MQTT_PAYLOAD_UNLOCK = "payload_unlock";
+constexpr const char *const MQTT_PERCENTAGE_COMMAND_TEMPLATE = "percentage_command_template";
+constexpr const char *const MQTT_PERCENTAGE_COMMAND_TOPIC = "percentage_command_topic";
+constexpr const char *const MQTT_PERCENTAGE_STATE_TOPIC = "percentage_state_topic";
+constexpr const char *const MQTT_PERCENTAGE_VALUE_TEMPLATE = "percentage_value_template";
 constexpr const char *const MQTT_POSITION_CLOSED = "position_closed";
 constexpr const char *const MQTT_POSITION_OPEN = "position_open";
+constexpr const char *const MQTT_POSITION_TEMPLATE = "position_template";
+constexpr const char *const MQTT_POSITION_TOPIC = "position_topic";
 constexpr const char *const MQTT_POWER_COMMAND_TOPIC = "power_command_topic";
-constexpr const char *const MQTT_POWER_STATE_TOPIC = "power_state_topic";
 constexpr const char *const MQTT_POWER_STATE_TEMPLATE = "power_state_template";
-constexpr const char *const MQTT_PRESET_MODE_COMMAND_TOPIC = "preset_mode_command_topic";
+constexpr const char *const MQTT_POWER_STATE_TOPIC = "power_state_topic";
 constexpr const char *const MQTT_PRESET_MODE_COMMAND_TEMPLATE = "preset_mode_command_template";
+constexpr const char *const MQTT_PRESET_MODE_COMMAND_TOPIC = "preset_mode_command_topic";
 constexpr const char *const MQTT_PRESET_MODE_STATE_TOPIC = "preset_mode_state_topic";
 constexpr const char *const MQTT_PRESET_MODE_VALUE_TEMPLATE = "preset_mode_value_template";
 constexpr const char *const MQTT_PRESET_MODES = "preset_modes";
@@ -444,36 +456,38 @@ constexpr const char *const MQTT_SEND_IF_OFF = "send_if_off";
 constexpr const char *const MQTT_SET_FAN_SPEED_TOPIC = "set_fan_speed_topic";
 constexpr const char *const MQTT_SET_POSITION_TEMPLATE = "set_position_template";
 constexpr const char *const MQTT_SET_POSITION_TOPIC = "set_position_topic";
-constexpr const char *const MQTT_POSITION_TOPIC = "position_topic";
+constexpr const char *const MQTT_SOURCE_TYPE = "source_type";
-constexpr const char *const MQTT_POSITION_TEMPLATE = "position_template";
 constexpr const char *const MQTT_SPEED_COMMAND_TOPIC = "speed_command_topic";
-constexpr const char *const MQTT_SPEED_STATE_TOPIC = "speed_state_topic";
-constexpr const char *const MQTT_SPEED_RANGE_MIN = "speed_range_min";
 constexpr const char *const MQTT_SPEED_RANGE_MAX = "speed_range_max";
+constexpr const char *const MQTT_SPEED_RANGE_MIN = "speed_range_min";
+constexpr const char *const MQTT_SPEED_STATE_TOPIC = "speed_state_topic";
 constexpr const char *const MQTT_SPEED_VALUE_TEMPLATE = "speed_value_template";
 constexpr const char *const MQTT_SPEEDS = "speeds";
-constexpr const char *const MQTT_SOURCE_TYPE = "source_type";
 constexpr const char *const MQTT_STATE_CLASS = "state_class";
 constexpr const char *const MQTT_STATE_CLOSED = "state_closed";
 constexpr const char *const MQTT_STATE_CLOSING = "state_closing";
+constexpr const char *const MQTT_STATE_LOCKED = "state_locked";
 constexpr const char *const MQTT_STATE_OFF = "state_off";
 constexpr const char *const MQTT_STATE_ON = "state_on";
 constexpr const char *const MQTT_STATE_OPEN = "state_open";
 constexpr const char *const MQTT_STATE_OPENING = "state_opening";
 constexpr const char *const MQTT_STATE_STOPPED = "state_stopped";
-constexpr const char *const MQTT_STATE_LOCKED = "state_locked";
-constexpr const char *const MQTT_STATE_UNLOCKED = "state_unlocked";
-constexpr const char *const MQTT_STATE_TOPIC = "state_topic";
 constexpr const char *const MQTT_STATE_TEMPLATE = "state_template";
+constexpr const char *const MQTT_STATE_TOPIC = "state_topic";
+constexpr const char *const MQTT_STATE_UNLOCKED = "state_unlocked";
 constexpr const char *const MQTT_STATE_VALUE_TEMPLATE = "state_value_template";
 constexpr const char *const MQTT_STEP = "step";
 constexpr const char *const MQTT_SUBTYPE = "subtype";
-constexpr const char *const MQTT_SUPPORTED_FEATURES = "supported_features";
 constexpr const char *const MQTT_SUPPORTED_COLOR_MODES = "supported_color_modes";
+constexpr const char *const MQTT_SUPPORTED_FEATURES = "supported_features";
 constexpr const char *const MQTT_SWING_MODE_COMMAND_TEMPLATE = "swing_mode_command_template";
 constexpr const char *const MQTT_SWING_MODE_COMMAND_TOPIC = "swing_mode_command_topic";
 constexpr const char *const MQTT_SWING_MODE_STATE_TEMPLATE = "swing_mode_state_template";
 constexpr const char *const MQTT_SWING_MODE_STATE_TOPIC = "swing_mode_state_topic";
+constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TEMPLATE = "target_humidity_command_template";
+constexpr const char *const MQTT_TARGET_HUMIDITY_COMMAND_TOPIC = "target_humidity_command_topic";
+constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TEMPLATE = "target_humidity_state_template";
+constexpr const char *const MQTT_TARGET_HUMIDITY_STATE_TOPIC = "target_humidity_state_topic";
 constexpr const char *const MQTT_TEMPERATURE_COMMAND_TEMPLATE = "temperature_command_template";
 constexpr const char *const MQTT_TEMPERATURE_COMMAND_TOPIC = "temperature_command_topic";
 constexpr const char *const MQTT_TEMPERATURE_HIGH_COMMAND_TEMPLATE = "temperature_high_command_template";
@@ -488,15 +502,15 @@ constexpr const char *const MQTT_TEMPERATURE_STATE_TEMPLATE = "temperature_state
 constexpr const char *const MQTT_TEMPERATURE_STATE_TOPIC = "temperature_state_topic";
 constexpr const char *const MQTT_TEMPERATURE_UNIT = "temperature_unit";
 constexpr const char *const MQTT_TILT_CLOSED_VALUE = "tilt_closed_value";
-constexpr const char *const MQTT_TILT_COMMAND_TOPIC = "tilt_command_topic";
 constexpr const char *const MQTT_TILT_COMMAND_TEMPLATE = "tilt_command_template";
+constexpr const char *const MQTT_TILT_COMMAND_TOPIC = "tilt_command_topic";
 constexpr const char *const MQTT_TILT_INVERT_STATE = "tilt_invert_state";
 constexpr const char *const MQTT_TILT_MAX = "tilt_max";
 constexpr const char *const MQTT_TILT_MIN = "tilt_min";
 constexpr const char *const MQTT_TILT_OPENED_VALUE = "tilt_opened_value";
 constexpr const char *const MQTT_TILT_OPTIMISTIC = "tilt_optimistic";
-constexpr const char *const MQTT_TILT_STATUS_TOPIC = "tilt_status_topic";
 constexpr const char *const MQTT_TILT_STATUS_TEMPLATE = "tilt_status_template";
+constexpr const char *const MQTT_TILT_STATUS_TOPIC = "tilt_status_topic";
 constexpr const char *const MQTT_TOPIC = "topic";
 constexpr const char *const MQTT_UNIQUE_ID = "unique_id";
 constexpr const char *const MQTT_UNIT_OF_MEASUREMENT = "unit_of_measurement";
@@ -511,19 +525,8 @@ constexpr const char *const MQTT_XY_COMMAND_TOPIC = "xy_command_topic";
 constexpr const char *const MQTT_XY_STATE_TOPIC = "xy_state_topic";
 constexpr const char *const MQTT_XY_VALUE_TEMPLATE = "xy_value_template";
 
-constexpr const char *const MQTT_DEVICE_CONNECTIONS = "connections";
-constexpr const char *const MQTT_DEVICE_IDENTIFIERS = "identifiers";
-constexpr const char *const MQTT_DEVICE_NAME = "name";
-constexpr const char *const MQTT_DEVICE_MANUFACTURER = "manufacturer";
-constexpr const char *const MQTT_DEVICE_MODEL = "model";
-constexpr const char *const MQTT_DEVICE_SW_VERSION = "sw_version";
-constexpr const char *const MQTT_DEVICE_SUGGESTED_AREA = "suggested_area";
 #endif
 
-// Additional MQTT fields where no abbreviation is defined in HA source
-constexpr const char *const MQTT_ENTITY_CATEGORY = "entity_category";
-constexpr const char *const MQTT_MODE = "mode";
-
 }  // namespace mqtt
 }  // namespace esphome
 

esphome/components/mqtt/mqtt_event.cpp

@@ -0,0 +1,54 @@
+#include "mqtt_event.h"
+#include "esphome/core/log.h"
+
+#include "mqtt_const.h"
+
+#ifdef USE_MQTT
+#ifdef USE_EVENT
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.event";
+
+using namespace esphome::event;
+
+MQTTEventComponent::MQTTEventComponent(event::Event *event) : event_(event) {}
+
+void MQTTEventComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
+  JsonArray event_types = root.createNestedArray(MQTT_EVENT_TYPES);
+  for (const auto &event_type : this->event_->get_event_types())
+    event_types.add(event_type);
+
+  if (!this->event_->get_device_class().empty())
+    root[MQTT_DEVICE_CLASS] = this->event_->get_device_class();
+
+  config.command_topic = false;
+}
+
+void MQTTEventComponent::setup() {
+  this->event_->add_on_event_callback([this](const std::string &event_type) { this->publish_event_(event_type); });
+}
+
+void MQTTEventComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "MQTT Event '%s': ", this->event_->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Event Types: ");
+  for (const auto &event_type : this->event_->get_event_types()) {
+    ESP_LOGCONFIG(TAG, "- %s", event_type.c_str());
+  }
+  LOG_MQTT_COMPONENT(true, true);
+}
+
+bool MQTTEventComponent::publish_event_(const std::string &event_type) {
+  return this->publish_json(this->get_state_topic_(),
+                            [event_type](JsonObject root) { root[MQTT_EVENT_TYPE] = event_type; });
+}
+
+std::string MQTTEventComponent::component_type() const { return "event"; }
+const EntityBase *MQTTEventComponent::get_entity() const { return this->event_; }
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_event.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_MQTT
+#ifdef USE_EVENT
+
+#include "esphome/components/event/event.h"
+#include "mqtt_component.h"
+
+namespace esphome {
+namespace mqtt {
+
+class MQTTEventComponent : public mqtt::MQTTComponent {
+ public:
+  explicit MQTTEventComponent(event::Event *event);
+
+  void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
+
+  void setup() override;
+
+  void dump_config() override;
+
+  /// Events do not send a state so just return true.
+  bool send_initial_state() override { return true; }
+
+ protected:
+  bool publish_event_(const std::string &event_type);
+  std::string component_type() const override;
+  const EntityBase *get_entity() const override;
+
+  event::Event *event_;
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_valve.cpp

@@ -0,0 +1,90 @@
+#include "mqtt_valve.h"
+#include "esphome/core/log.h"
+
+#include "mqtt_const.h"
+
+#ifdef USE_MQTT
+#ifdef USE_VALVE
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.valve";
+
+using namespace esphome::valve;
+
+MQTTValveComponent::MQTTValveComponent(Valve *valve) : valve_(valve) {}
+void MQTTValveComponent::setup() {
+  auto traits = this->valve_->get_traits();
+  this->valve_->add_on_state_callback([this]() { this->publish_state(); });
+  this->subscribe(this->get_command_topic_(), [this](const std::string &topic, const std::string &payload) {
+    auto call = this->valve_->make_call();
+    call.set_command(payload.c_str());
+    call.perform();
+  });
+  if (traits.get_supports_position()) {
+    this->subscribe(this->get_position_command_topic(), [this](const std::string &topic, const std::string &payload) {
+      auto value = parse_number<float>(payload);
+      if (!value.has_value()) {
+        ESP_LOGW(TAG, "Invalid position value: '%s'", payload.c_str());
+        return;
+      }
+      auto call = this->valve_->make_call();
+      call.set_position(*value / 100.0f);
+      call.perform();
+    });
+  }
+}
+
+void MQTTValveComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "MQTT valve '%s':", this->valve_->get_name().c_str());
+  auto traits = this->valve_->get_traits();
+  bool has_command_topic = traits.get_supports_position();
+  LOG_MQTT_COMPONENT(true, has_command_topic)
+  if (traits.get_supports_position()) {
+    ESP_LOGCONFIG(TAG, "  Position State Topic: '%s'", this->get_position_state_topic().c_str());
+    ESP_LOGCONFIG(TAG, "  Position Command Topic: '%s'", this->get_position_command_topic().c_str());
+  }
+}
+void MQTTValveComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
+  if (!this->valve_->get_device_class().empty())
+    root[MQTT_DEVICE_CLASS] = this->valve_->get_device_class();
+
+  auto traits = this->valve_->get_traits();
+  if (traits.get_is_assumed_state()) {
+    root[MQTT_OPTIMISTIC] = true;
+  }
+  if (traits.get_supports_position()) {
+    root[MQTT_POSITION_TOPIC] = this->get_position_state_topic();
+    root[MQTT_SET_POSITION_TOPIC] = this->get_position_command_topic();
+  }
+}
+
+std::string MQTTValveComponent::component_type() const { return "valve"; }
+const EntityBase *MQTTValveComponent::get_entity() const { return this->valve_; }
+
+bool MQTTValveComponent::send_initial_state() { return this->publish_state(); }
+bool MQTTValveComponent::publish_state() {
+  auto traits = this->valve_->get_traits();
+  bool success = true;
+  if (traits.get_supports_position()) {
+    std::string pos = value_accuracy_to_string(roundf(this->valve_->position * 100), 0);
+    if (!this->publish(this->get_position_state_topic(), pos))
+      success = false;
+  }
+  const char *state_s = this->valve_->current_operation == VALVE_OPERATION_OPENING   ? "opening"
+                        : this->valve_->current_operation == VALVE_OPERATION_CLOSING ? "closing"
+                        : this->valve_->position == VALVE_CLOSED                     ? "closed"
+                        : this->valve_->position == VALVE_OPEN                       ? "open"
+                        : traits.get_supports_position()                             ? "open"
+                                                                                     : "unknown";
+  if (!this->publish(this->get_state_topic_(), state_s))
+    success = false;
+  return success;
+}
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_valve.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#include "mqtt_component.h"
+
+#ifdef USE_MQTT
+#ifdef USE_VALVE
+
+#include "esphome/components/valve/valve.h"
+
+namespace esphome {
+namespace mqtt {
+
+class MQTTValveComponent : public mqtt::MQTTComponent {
+ public:
+  explicit MQTTValveComponent(valve::Valve *valve);
+
+  void setup() override;
+  void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
+
+  MQTT_COMPONENT_CUSTOM_TOPIC(position, command)
+  MQTT_COMPONENT_CUSTOM_TOPIC(position, state)
+
+  bool send_initial_state() override;
+
+  bool publish_state();
+
+  void dump_config() override;
+
+ protected:
+  std::string component_type() const override;
+  const EntityBase *get_entity() const override;
+
+  valve::Valve *valve_;
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif
+#endif  // USE_MQTT

esphome/components/nextion/binary_sensor/nextion_binarysensor.cpp

@@ -27,7 +27,7 @@ void NextionBinarySensor::process_touch(uint8_t page_id, uint8_t component_id, b
 }
 
 void NextionBinarySensor::update() {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (this->variable_name_.empty())  // This is a touch component
@@ -37,7 +37,7 @@ void NextionBinarySensor::update() {
 }
 
 void NextionBinarySensor::set_state(bool state, bool publish, bool send_to_nextion) {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (this->component_id_ == 0)  // This is a legacy touch component

esphome/components/nextion/display.py

@@ -68,8 +68,8 @@ CONFIG_SCHEMA = (
                 }
             ),
             cv.Optional(CONF_TOUCH_SLEEP_TIMEOUT): cv.int_range(min=3, max=65535),
-            cv.Optional(CONF_WAKE_UP_PAGE): cv.positive_int,
+            cv.Optional(CONF_WAKE_UP_PAGE): cv.uint8_t,
-            cv.Optional(CONF_START_UP_PAGE): cv.positive_int,
+            cv.Optional(CONF_START_UP_PAGE): cv.uint8_t,
             cv.Optional(CONF_AUTO_WAKE_ON_TOUCH, default=True): cv.boolean,
             cv.Optional(CONF_EXIT_REPARSE_ON_START, default=False): cv.boolean,
         }

esphome/components/nextion/nextion.cpp

@@ -138,11 +138,11 @@ void Nextion::dump_config() {
   }
 
   if (this->wake_up_page_ != -1) {
-    ESP_LOGCONFIG(TAG, "  Wake Up Page:     %d", this->wake_up_page_);
+    ESP_LOGCONFIG(TAG, "  Wake Up Page:     %" PRId16, this->wake_up_page_);
   }
 
   if (this->start_up_page_ != -1) {
-    ESP_LOGCONFIG(TAG, "  Start Up Page:    %d", this->start_up_page_);
+    ESP_LOGCONFIG(TAG, "  Start Up Page:    %" PRId16, this->start_up_page_);
   }
 }
 
@@ -194,6 +194,17 @@ void Nextion::update_all_components() {
   }
 }
 
+bool Nextion::send_command(const char *command) {
+  if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
+    return false;
+
+  if (this->send_command_(command)) {
+    this->add_no_result_to_queue_("send_command");
+    return true;
+  }
+  return false;
+}
+
 bool Nextion::send_command_printf(const char *format, ...) {
   if ((!this->is_setup() && !this->ignore_is_setup_) || this->is_sleeping())
     return false;
@@ -1024,23 +1035,23 @@ bool Nextion::add_no_result_to_queue_with_printf_(const std::string &variable_na
  * @param is_sleep_safe The command is safe to send when the Nextion is sleeping
  */
 
-void Nextion::add_no_result_to_queue_with_set(NextionComponentBase *component, int state_value) {
+void Nextion::add_no_result_to_queue_with_set(NextionComponentBase *component, int32_t state_value) {
   this->add_no_result_to_queue_with_set(component->get_variable_name(), component->get_variable_name_to_send(),
                                         state_value);
 }
 
 void Nextion::add_no_result_to_queue_with_set(const std::string &variable_name,
-                                              const std::string &variable_name_to_send, int state_value) {
+                                              const std::string &variable_name_to_send, int32_t state_value) {
   this->add_no_result_to_queue_with_set_internal_(variable_name, variable_name_to_send, state_value);
 }
 
 void Nextion::add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
-                                                        const std::string &variable_name_to_send, int state_value,
+                                                        const std::string &variable_name_to_send, int32_t state_value,
                                                         bool is_sleep_safe) {
   if ((!this->is_setup() && !this->ignore_is_setup_) || (!is_sleep_safe && this->is_sleeping()))
     return;
 
-  this->add_no_result_to_queue_with_ignore_sleep_printf_(variable_name, "%s=%d", variable_name_to_send.c_str(),
+  this->add_no_result_to_queue_with_ignore_sleep_printf_(variable_name, "%s=%" PRId32, variable_name_to_send.c_str(),
                                                          state_value);
 }
 
@@ -1137,5 +1148,7 @@ void Nextion::set_writer(const nextion_writer_t &writer) { this->writer_ = write
 ESPDEPRECATED("set_wait_for_ack(bool) is deprecated and has no effect", "v1.20")
 void Nextion::set_wait_for_ack(bool wait_for_ack) { ESP_LOGE(TAG, "This command is deprecated"); }
 
+bool Nextion::is_updating() { return this->is_updating_; }
+
 }  // namespace nextion
 }  // namespace esphome

esphome/components/nextion/nextion.h

@@ -50,6 +50,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will set the `txt` property of the component `textview` to `Hello World`.
    */
   void set_component_text(const char *component, const char *text);
+
   /**
    * Set the text of a component to a formatted string
    * @param component The component name.
@@ -66,6 +67,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * For example when `uptime_sensor` = 506, then, `The uptime is: 506` will be displayed.
    */
   void set_component_text_printf(const char *component, const char *format, ...) __attribute__((format(printf, 3, 4)));
+
   /**
    * Set the integer value of a component
    * @param component The component name.
@@ -78,7 +80,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * This will change the property `value` of the component `gauge` to 50.
    */
-  void set_component_value(const char *component, int value);
+  void set_component_value(const char *component, int32_t value);
+
   /**
    * Set the picture of an image component.
    * @param component The component name.
@@ -92,6 +95,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the image of the component `pic` to the image with ID `4`.
    */
   void set_component_picture(const char *component, uint8_t picture_id);
+
   /**
    * Set the background color of a component.
    * @param component The component name.
@@ -107,6 +111,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_background_color(const char *component, uint16_t color);
+
   /**
    * Set the background color of a component.
    * @param component The component name.
@@ -121,6 +126,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_background_color(const char *component, const char *color);
+
   /**
    * Set the background color of a component.
    * @param component The component name.
@@ -135,6 +141,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the background color of the component `button` to blue.
    */
   void set_component_background_color(const char *component, Color color) override;
+
   /**
    * Set the pressed background color of a component.
    * @param component The component name.
@@ -151,6 +158,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_pressed_background_color(const char *component, uint16_t color);
+
   /**
    * Set the pressed background color of a component.
    * @param component The component name.
@@ -166,6 +174,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_pressed_background_color(const char *component, const char *color);
+
   /**
    * Set the pressed background color of a component.
    * @param component The component name.
@@ -181,6 +190,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * is shown when the component is pressed.
    */
   void set_component_pressed_background_color(const char *component, Color color) override;
+
   /**
    * Set the foreground color of a component.
    * @param component The component name.
@@ -196,6 +206,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_foreground_color(const char *component, uint16_t color);
+
   /**
    * Set the foreground color of a component.
    * @param component The component name.
@@ -210,6 +221,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_foreground_color(const char *component, const char *color);
+
   /**
    * Set the foreground color of a component.
    * @param component The component name.
@@ -223,6 +235,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the foreground color of the component `button` to black.
    */
   void set_component_foreground_color(const char *component, Color color) override;
+
   /**
    * Set the pressed foreground color of a component.
    * @param component The component name.
@@ -239,6 +252,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_pressed_foreground_color(const char *component, uint16_t color);
+
   /**
    * Set the pressed foreground color of a component.
    * @param component The component name.
@@ -254,6 +268,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_pressed_foreground_color(const char *component, const char *color);
+
   /**
    * Set the pressed foreground color of a component.
    * @param component The component name.
@@ -283,6 +298,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the picture id of the component `textview`.
    */
   void set_component_pic(const char *component, uint8_t pic_id);
+
   /**
    * Set the background picture id of component.
    * @param component The component name.
@@ -312,6 +328,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_font_color(const char *component, uint16_t color);
+
   /**
    * Set the font color of a component.
    * @param component The component name.
@@ -326,6 +343,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_font_color(const char *component, const char *color);
+
   /**
    * Set the font color of a component.
    * @param component The component name.
@@ -339,6 +357,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the font color of the component `textview` to black.
    */
   void set_component_font_color(const char *component, Color color) override;
+
   /**
    * Set the pressed font color of a component.
    * @param component The component name.
@@ -354,6 +373,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Nextion HMI colors.
    */
   void set_component_pressed_font_color(const char *component, uint16_t color);
+
   /**
    * Set the pressed font color of a component.
    * @param component The component name.
@@ -368,6 +388,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
   void set_component_pressed_font_color(const char *component, const char *color);
+
   /**
    * Set the pressed font color of a component.
    * @param component The component name.
@@ -381,6 +402,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * This will change the pressed font color of the component `button` to black.
    */
   void set_component_pressed_font_color(const char *component, Color color) override;
+
   /**
    * Set the coordinates of a component on screen.
    * @param component The component name.
@@ -394,7 +416,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * This will move the position of the component `pic` to the x coordinate `55` and y coordinate `100`.
    */
-  void set_component_coordinates(const char *component, int x, int y);
+  void set_component_coordinates(const char *component, uint16_t x, uint16_t y);
+
   /**
    * Set the font id for a component.
    * @param component The component name.
@@ -408,6 +431,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Changes the font of the component named `textveiw`. Font IDs are set in the Nextion Editor.
    */
   void set_component_font(const char *component, uint8_t font_id) override;
+
   /**
    * Send the current time to the nextion display.
    * @param time The time instance to send (get this with id(my_time).now() ).
@@ -426,6 +450,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Switches to the page named `main`. Pages are named in the Nextion Editor.
    */
   void goto_page(const char *page);
+
   /**
    * Show the page with a given id.
    * @param page The id of the page.
@@ -438,6 +463,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Switches to the page named `main`. Pages are named in the Nextion Editor.
    */
   void goto_page(uint8_t page);
+
   /**
    * Hide a component.
    * @param component The component name.
@@ -450,6 +476,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Hides the component named `button`.
    */
   void hide_component(const char *component) override;
+
   /**
    * Show a component.
    * @param component The component name.
@@ -462,6 +489,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Shows the component named `button`.
    */
   void show_component(const char *component) override;
+
   /**
    * Enable touch for a component.
    * @param component The component name.
@@ -474,6 +502,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Enables touch for component named `button`.
    */
   void enable_component_touch(const char *component);
+
   /**
    * Disable touch for a component.
    * @param component The component name.
@@ -486,14 +515,17 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Disables touch for component named `button`.
    */
   void disable_component_touch(const char *component);
+
   /**
    * Add waveform data to a waveform component
    * @param component_id The integer component id.
    * @param channel_number The channel number to write to.
    * @param value The value to write.
    */
-  void add_waveform_data(int component_id, uint8_t channel_number, uint8_t value);
+  void add_waveform_data(uint8_t component_id, uint8_t channel_number, uint8_t value);
-  void open_waveform_channel(int component_id, uint8_t channel_number, uint8_t value);
+
+  void open_waveform_channel(uint8_t component_id, uint8_t channel_number, uint8_t value);
+
   /**
    * Display a picture at coordinates.
    * @param picture_id The picture id.
@@ -507,7 +539,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * Displays the picture who has the id `2` at the x coordinates `15` and y coordinates `25`.
    */
-  void display_picture(int picture_id, int x_start, int y_start);
+  void display_picture(uint16_t picture_id, uint16_t x_start, uint16_t y_start);
+
   /**
    * Fill a rectangle with a color.
    * @param x1 The starting x coordinate.
@@ -526,7 +559,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use this [color picker](https://nodtem66.github.io/nextion-hmi-color-convert/index.html) to convert color codes to
    * Nextion HMI colors.
    */
-  void fill_area(int x1, int y1, int width, int height, uint16_t color);
+  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color);
+
   /**
    * Fill a rectangle with a color.
    * @param x1 The starting x coordinate.
@@ -544,7 +578,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * the red color.
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
-  void fill_area(int x1, int y1, int width, int height, const char *color);
+  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color);
+
   /**
    * Fill a rectangle with a color.
    * @param x1 The starting x coordinate.
@@ -562,7 +597,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Fills an area that starts at x coordinate `50` and y coordinate `50` with a height of `100` and width of `100` with
    * blue color.
    */
-  void fill_area(int x1, int y1, int width, int height, Color color);
+  void fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color);
+
   /**
    * Draw a line on the screen.
    * @param x1 The starting x coordinate.
@@ -581,7 +617,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use this [color picker](https://nodtem66.github.io/nextion-hmi-color-convert/index.html) to convert color codes to
    * Nextion HMI colors.
    */
-  void line(int x1, int y1, int x2, int y2, uint16_t color);
+  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);
+
   /**
    * Draw a line on the screen.
    * @param x1 The starting x coordinate.
@@ -599,7 +636,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * `75` with the blue color.
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
-  void line(int x1, int y1, int x2, int y2, const char *color);
+  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, const char *color);
+
   /**
    * Draw a line on the screen.
    * @param x1 The starting x coordinate.
@@ -617,7 +655,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Makes a line that starts at x coordinate `50` and y coordinate `50` and ends at x coordinate `75` and y coordinate
    * `75` with blue color.
    */
-  void line(int x1, int y1, int x2, int y2, Color color);
+  void line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color);
+
   /**
    * Draw a rectangle outline.
    * @param x1 The starting x coordinate.
@@ -636,7 +675,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use this [color picker](https://nodtem66.github.io/nextion-hmi-color-convert/index.html) to convert color codes to
    * Nextion HMI colors.
    */
-  void rectangle(int x1, int y1, int width, int height, uint16_t color);
+  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color);
+
   /**
    * Draw a rectangle outline.
    * @param x1 The starting x coordinate.
@@ -654,7 +694,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * length of `50` with the blue color.
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
-  void rectangle(int x1, int y1, int width, int height, const char *color);
+  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color);
+
   /**
    * Draw a rectangle outline.
    * @param x1 The starting x coordinate.
@@ -672,7 +713,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Makes a outline of a rectangle that starts at x coordinate `25` and y coordinate `35` and has a width of `40` and a
    * length of `50` with blue color.
    */
-  void rectangle(int x1, int y1, int width, int height, Color color);
+  void rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color);
+
   /**
    * Draw a circle outline
    * @param center_x The center x coordinate.
@@ -682,7 +724,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use this [color picker](https://nodtem66.github.io/nextion-hmi-color-convert/index.html) to convert color codes to
    * Nextion HMI colors.
    */
-  void circle(int center_x, int center_y, int radius, uint16_t color);
+  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color);
+
   /**
    * Draw a circle outline
    * @param center_x The center x coordinate.
@@ -691,7 +734,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * @param color The color to draw with (as a string).
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
-  void circle(int center_x, int center_y, int radius, const char *color);
+  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color);
+
   /**
    * Draw a circle outline
    * @param center_x The center x coordinate.
@@ -699,7 +743,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * @param radius The circle radius.
    * @param color The color to draw with (as Color).
    */
-  void circle(int center_x, int center_y, int radius, Color color);
+  void circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color);
+
   /**
    * Draw a filled circled.
    * @param center_x The center x coordinate.
@@ -716,7 +761,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Use this [color picker](https://nodtem66.github.io/nextion-hmi-color-convert/index.html) to convert color codes to
    * Nextion HMI colors.
    */
-  void filled_circle(int center_x, int center_y, int radius, uint16_t color);
+  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color);
+
   /**
    * Draw a filled circled.
    * @param center_x The center x coordinate.
@@ -732,7 +778,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Makes a filled circle at the x coordinate `25` and y coordinate `25` with a radius of `10` with the blue color.
    * Use [Nextion Instruction Set](https://nextion.tech/instruction-set/#s5) for a list of Nextion HMI colors constants.
    */
-  void filled_circle(int center_x, int center_y, int radius, const char *color);
+  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color);
+
   /**
    * Draw a filled circled.
    * @param center_x The center x coordinate.
@@ -748,7 +795,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * Makes a filled circle at the x coordinate `25` and y coordinate `25` with a radius of `10` with blue color.
    */
-  void filled_circle(int center_x, int center_y, int radius, Color color);
+  void filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color);
 
   /**
    * Draws a QR code in the screen
@@ -768,8 +815,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * Draws a QR code with a Wi-Fi network credentials starting at the given coordinates (25,25).
    */
-  void qrcode(int x1, int y1, const char *content, int size = 200, uint16_t background_color = 65535,
+  void qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size = 200, uint16_t background_color = 65535,
-              uint16_t foreground_color = 0, int logo_pic = -1, uint8_t border_width = 8);
+              uint16_t foreground_color = 0, uint8_t logo_pic = -1, uint8_t border_width = 8);
+
   /**
    * Draws a QR code in the screen
    * @param x1 The top left x coordinate to start the QR code.
@@ -791,8 +839,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Draws a QR code with a Wi-Fi network credentials starting at the given coordinates (25,25) with size of 150px in
    * red on a blue background.
    */
-  void qrcode(int x1, int y1, const char *content, int size, Color background_color = Color(255, 255, 255),
+  void qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size,
-              Color foreground_color = Color(0, 0, 0), int logo_pic = -1, uint8_t border_width = 8);
+              Color background_color = Color(255, 255, 255), Color foreground_color = Color(0, 0, 0),
+              uint8_t logo_pic = -1, uint8_t border_width = 8);
 
   /** Set the brightness of the backlight.
    *
@@ -806,6 +855,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Changes the brightness of the display to 30%.
    */
   void set_backlight_brightness(float brightness);
+
   /**
    * Set the touch sleep timeout of the display.
    * @param timeout Timeout in seconds.
@@ -819,6 +869,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * `thup`.
    */
   void set_touch_sleep_timeout(uint16_t timeout);
+
   /**
    * Sets which page Nextion loads when exiting sleep mode. Note this can be set even when Nextion is in sleep mode.
    * @param page_id The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
@@ -832,6 +883,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * The display will wake up to page 2.
    */
   void set_wake_up_page(uint8_t page_id = 255);
+
   /**
    * Sets which page Nextion loads when connecting to ESPHome.
    * @param page_id The page id, from 0 to the lage page in Nextion. Set 255 (not set to any existing page) to
@@ -859,6 +911,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * The display will wake up by touch.
    */
   void set_auto_wake_on_touch(bool auto_wake);
+
   /**
    * Sets if Nextion should exit the active reparse mode before the "connect" command is sent
    * @param exit_reparse True or false. When exit_reparse is true, the exit reparse command
@@ -872,18 +925,32 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * The display will be requested to leave active reparse mode before setup.
    */
   void set_exit_reparse_on_start(bool exit_reparse);
+
   /**
    * Sets Nextion mode between sleep and awake
    * @param True or false. Sleep=true to enter sleep mode or sleep=false to exit sleep mode.
    */
   void sleep(bool sleep);
+
   /**
-   * Sets Nextion Protocol Reparse mode between active or passive
+   * @brief Sets the Nextion display's protocol reparse mode.
-   * @param True or false.
+   *
-   * active_mode=true to enter active protocol reparse mode
+   * This function toggles the Nextion display's protocol reparse mode between active and passive.
-   * active_mode=false to enter passive protocol reparse mode.
+   * In active mode, the display actively parses incoming data.
+   * In passive mode, it does not parse data unless specifically instructed to do so.
+   * This is useful for managing how the Nextion display interprets incoming commands,
+   * especially during initialization or in scenarios where precise control over command processing is needed.
+   *
+   * @param active_mode A boolean value indicating the desired reparse mode.
+   *        - true to set the display to active protocol reparse mode, where it actively parses incoming commands.
+   *        - false to set the display to passive protocol reparse mode, where command parsing is done only on explicit
+   * instruction.
+   *
+   * @return bool Returns true if all commands were sent successfully to the Nextion display, indicating that the mode
+   * was set as expected. Returns false if any of the commands failed to send, indicating that the desired reparse mode
+   * may not be correctly set.
    */
-  void set_protocol_reparse_mode(bool active_mode);
+  bool set_protocol_reparse_mode(bool active_mode);
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
@@ -903,6 +970,12 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   // This function has been deprecated
   void set_wait_for_ack(bool wait_for_ack);
 
+  /**
+   * Manually send a raw command to the display.
+   * @param command The pcommand, like "page 0"
+   * @return Whether the send was successful.
+   */
+  bool send_command(const char *command);
   /**
    * Manually send a raw formatted command to the display.
    * @param format The printf-style command format, like "vis %s,0"
@@ -916,7 +989,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    * Set the tft file URL. https seems problematic with arduino..
    */
   void set_tft_url(const std::string &tft_url) { this->tft_url_ = tft_url; }
-
 #endif
 
   /**
@@ -980,9 +1052,9 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void set_nextion_sensor_state(NextionQueueType queue_type, const std::string &name, float state);
   void set_nextion_text_state(const std::string &name, const std::string &state);
 
-  void add_no_result_to_queue_with_set(NextionComponentBase *component, int state_value) override;
+  void add_no_result_to_queue_with_set(NextionComponentBase *component, int32_t state_value) override;
   void add_no_result_to_queue_with_set(const std::string &variable_name, const std::string &variable_name_to_send,
-                                       int state_value) override;
+                                       int32_t state_value) override;
 
   void add_no_result_to_queue_with_set(NextionComponentBase *component, const std::string &state_value) override;
   void add_no_result_to_queue_with_set(const std::string &variable_name, const std::string &variable_name_to_send,
@@ -1019,6 +1091,26 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    */
   size_t queue_size() { return this->nextion_queue_.size(); }
 
+  /**
+   * @brief Check if the TFT update process is currently running.
+   *
+   * This method provides a way to determine if the Nextion display is in the
+   * process of updating its TFT firmware. When a TFT update is in progress,
+   * certain operations or commands may be restricted or could interfere with the
+   * update process. By checking the state of the update process, the system can
+   * make informed decisions about performing actions that involve communication
+   * with the Nextion display.
+   *
+   * @return true if the TFT update process is active, indicating that the Nextion
+   *         display is currently updating its firmware. This implies that caution
+   *         should be taken with commands sent to the display to avoid interrupting
+   *         the update process.
+   * @return false if the TFT update process is not active, indicating that the Nextion
+   *         display is not currently updating its firmware and is in a normal operational
+   *         state, ready to receive and process commands as usual.
+   */
+  bool is_updating() override;
+
  protected:
   std::deque<NextionQueue *> nextion_queue_;
   std::deque<NextionQueue *> waveform_queue_;
@@ -1038,8 +1130,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void process_serial_();
   bool is_updating_ = false;
   uint32_t touch_sleep_timeout_ = 0;
-  int wake_up_page_ = -1;
+  int16_t wake_up_page_ = -1;
-  int start_up_page_ = -1;
+  int16_t start_up_page_ = -1;
   bool auto_wake_on_touch_ = true;
   bool exit_reparse_on_start_ = false;
 
@@ -1057,7 +1149,7 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
       __attribute__((format(printf, 3, 4)));
 
   void add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
-                                                 const std::string &variable_name_to_send, int state_value,
+                                                 const std::string &variable_name_to_send, int32_t state_value,
                                                  bool is_sleep_safe = false);
 
   void add_no_result_to_queue_with_set_internal_(const std::string &variable_name,
@@ -1067,13 +1159,21 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
   void check_pending_waveform_();
 
 #ifdef USE_NEXTION_TFT_UPLOAD
+  uint32_t content_length_ = 0;
+  int tft_size_ = 0;
+  uint32_t original_baud_rate_ = 0;
+  bool upload_first_chunk_sent_ = false;
+
+  std::string tft_url_;
+  uint8_t *transfer_buffer_{nullptr};
+  size_t transfer_buffer_size_;
+
 #ifdef USE_ESP8266
   WiFiClient *wifi_client_{nullptr};
   BearSSL::WiFiClientSecure *wifi_client_secure_{nullptr};
   WiFiClient *get_wifi_client_();
 #endif
-  int content_length_ = 0;
+
-  int tft_size_ = 0;
 #ifdef ARDUINO
   /**
    * will request chunk_size chunks from the web server
@@ -1146,13 +1246,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
   void remove_front_no_sensors_();
 
-#ifdef USE_NEXTION_TFT_UPLOAD
-  std::string tft_url_;
-  uint8_t *transfer_buffer_{nullptr};
-  size_t transfer_buffer_size_;
-  bool upload_first_chunk_sent_ = false;
-#endif
-
 #ifdef NEXTION_PROTOCOL_LOG
   void print_queue_members_();
 #endif
@@ -1160,8 +1253,8 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
   std::string command_data_;
   bool is_connected_ = false;
-  uint32_t startup_override_ms_ = 8000;
+  const uint16_t startup_override_ms_ = 8000;
-  uint32_t max_q_age_ms_ = 8000;
+  const uint16_t max_q_age_ms_ = 8000;
   uint32_t started_ms_ = 0;
   bool sent_setup_commands_ = false;
 };

esphome/components/nextion/nextion_base.h

@@ -24,9 +24,9 @@ class NextionBase;
 
 class NextionBase {
  public:
-  virtual void add_no_result_to_queue_with_set(NextionComponentBase *component, int state_value) = 0;
+  virtual void add_no_result_to_queue_with_set(NextionComponentBase *component, int32_t state_value) = 0;
   virtual void add_no_result_to_queue_with_set(const std::string &variable_name,
-                                               const std::string &variable_name_to_send, int state_value) = 0;
+                                               const std::string &variable_name_to_send, int32_t state_value) = 0;
 
   virtual void add_no_result_to_queue_with_set(NextionComponentBase *component, const std::string &state_value) = 0;
   virtual void add_no_result_to_queue_with_set(const std::string &variable_name,
@@ -48,6 +48,8 @@ class NextionBase {
   virtual void show_component(const char *component) = 0;
   virtual void hide_component(const char *component) = 0;
 
+  virtual bool is_updating() { return false; }
+
   bool is_sleeping() { return this->is_sleeping_; }
   bool is_setup() { return this->is_setup_; }
   bool is_detected() { return this->is_detected_; }

esphome/components/nextion/nextion_commands.cpp

@@ -36,22 +36,23 @@ void Nextion::sleep(bool sleep) {
 // End sleep safe commands
 
 // Protocol reparse mode
-void Nextion::set_protocol_reparse_mode(bool active_mode) {
+bool Nextion::set_protocol_reparse_mode(bool active_mode) {
-  const uint8_t to_send[3] = {0xFF, 0xFF, 0xFF};
+  ESP_LOGV(TAG, "Set Nextion protocol reparse mode: %s", YESNO(active_mode));
+  this->ignore_is_setup_ = true;  // if not in reparse mode setup will fail, so it should be ignored
+  bool all_commands_sent = true;
   if (active_mode) {  // Sets active protocol reparse mode
-    this->write_str(
+    all_commands_sent &= this->send_command_("recmod=1");
-        "recmod=1");  // send_command_ cannot be used as Nextion might not be setup if incorrect reparse mode
-    this->write_array(to_send, sizeof(to_send));
   } else {  // Sets passive protocol reparse mode
-    this->write_str("DRAKJHSUYDGBNCJHGJKSHBDN");  // To exit active reparse mode this sequence must be sent
+    all_commands_sent &=
-    this->write_array(to_send, sizeof(to_send));
+        this->send_command_("DRAKJHSUYDGBNCJHGJKSHBDN");   // To exit active reparse mode this sequence must be sent
-    this->write_str("recmod=0");  // Sending recmode=0 twice is recommended
+    all_commands_sent &= this->send_command_("recmod=0");  // Sending recmode=0 twice is recommended
-    this->write_array(to_send, sizeof(to_send));
+    all_commands_sent &= this->send_command_("recmod=0");
-    this->write_str("recmod=0");
-    this->write_array(to_send, sizeof(to_send));
   }
-  this->write_str("connect");
+  if (!this->nextion_reports_is_setup_) {  // No need to connect if is already setup
-  this->write_array(to_send, sizeof(to_send));
+    all_commands_sent &= this->send_command_("connect");
+  }
+  this->ignore_is_setup_ = false;
+  return all_commands_sent;
 }
 void Nextion::set_exit_reparse_on_start(bool exit_reparse) { this->exit_reparse_on_start_ = exit_reparse; }
 
@@ -143,11 +144,11 @@ void Nextion::set_component_pressed_font_color(const char *component, Color colo
 
 // Set picture
 void Nextion::set_component_pic(const char *component, uint8_t pic_id) {
-  this->add_no_result_to_queue_with_printf_("set_component_pic", "%s.pic=%d", component, pic_id);
+  this->add_no_result_to_queue_with_printf_("set_component_pic", "%s.pic=%" PRIu8, component, pic_id);
 }
 
 void Nextion::set_component_picc(const char *component, uint8_t pic_id) {
-  this->add_no_result_to_queue_with_printf_("set_component_pic", "%s.picc=%d", component, pic_id);
+  this->add_no_result_to_queue_with_printf_("set_component_pic", "%s.picc=%" PRIu8, component, pic_id);
 }
 
 void Nextion::set_component_text_printf(const char *component, const char *format, ...) {
@@ -178,7 +179,7 @@ void Nextion::set_auto_wake_on_touch(bool auto_wake) {
 
 // General Component
 void Nextion::set_component_font(const char *component, uint8_t font_id) {
-  this->add_no_result_to_queue_with_printf_("set_component_font", "%s.font=%d", component, font_id);
+  this->add_no_result_to_queue_with_printf_("set_component_font", "%s.font=%" PRIu8, component, font_id);
 }
 
 void Nextion::hide_component(const char *component) {
@@ -198,113 +199,130 @@ void Nextion::disable_component_touch(const char *component) {
 }
 
 void Nextion::set_component_picture(const char *component, uint8_t picture_id) {
-  this->add_no_result_to_queue_with_printf_("set_component_picture", "%s.pic=%d", component, picture_id);
+  this->add_no_result_to_queue_with_printf_("set_component_picture", "%s.pic=%" PRIu8, component, picture_id);
 }
 
 void Nextion::set_component_text(const char *component, const char *text) {
   this->add_no_result_to_queue_with_printf_("set_component_text", "%s.txt=\"%s\"", component, text);
 }
 
-void Nextion::set_component_value(const char *component, int value) {
+void Nextion::set_component_value(const char *component, int32_t value) {
-  this->add_no_result_to_queue_with_printf_("set_component_value", "%s.val=%d", component, value);
+  this->add_no_result_to_queue_with_printf_("set_component_value", "%s.val=%" PRId32, component, value);
 }
 
-void Nextion::add_waveform_data(int component_id, uint8_t channel_number, uint8_t value) {
+void Nextion::add_waveform_data(uint8_t component_id, uint8_t channel_number, uint8_t value) {
-  this->add_no_result_to_queue_with_printf_("add_waveform_data", "add %d,%u,%u", component_id, channel_number, value);
+  this->add_no_result_to_queue_with_printf_("add_waveform_data", "add %" PRIu8 ",%" PRIu8 ",%" PRIu8, component_id,
+                                            channel_number, value);
 }
 
-void Nextion::open_waveform_channel(int component_id, uint8_t channel_number, uint8_t value) {
+void Nextion::open_waveform_channel(uint8_t component_id, uint8_t channel_number, uint8_t value) {
-  this->add_no_result_to_queue_with_printf_("open_waveform_channel", "addt %d,%u,%u", component_id, channel_number,
+  this->add_no_result_to_queue_with_printf_("open_waveform_channel", "addt %" PRIu8 ",%" PRIu8 ",%" PRIu8, component_id,
-                                            value);
+                                            channel_number, value);
 }
 
-void Nextion::set_component_coordinates(const char *component, int x, int y) {
+void Nextion::set_component_coordinates(const char *component, uint16_t x, uint16_t y) {
-  this->add_no_result_to_queue_with_printf_("set_component_coordinates command 1", "%s.xcen=%d", component, x);
+  this->add_no_result_to_queue_with_printf_("set_component_coordinates command 1", "%s.xcen=%" PRIu16, component, x);
-  this->add_no_result_to_queue_with_printf_("set_component_coordinates command 2", "%s.ycen=%d", component, y);
+  this->add_no_result_to_queue_with_printf_("set_component_coordinates command 2", "%s.ycen=%" PRIu16, component, y);
 }
 
 // Drawing
-void Nextion::display_picture(int picture_id, int x_start, int y_start) {
+void Nextion::display_picture(uint16_t picture_id, uint16_t x_start, uint16_t y_start) {
-  this->add_no_result_to_queue_with_printf_("display_picture", "pic %d, %d, %d", x_start, y_start, picture_id);
+  this->add_no_result_to_queue_with_printf_("display_picture", "pic %" PRIu16 ", %" PRIu16 ", %" PRIu16, x_start,
+                                            y_start, picture_id);
 }
 
-void Nextion::fill_area(int x1, int y1, int width, int height, uint16_t color) {
+void Nextion::fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color) {
-  this->add_no_result_to_queue_with_printf_("fill_area", "fill %d,%d,%d,%d,%" PRIu16, x1, y1, width, height, color);
+  this->add_no_result_to_queue_with_printf_(
+      "fill_area", "fill %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1, y1, width, height, color);
 }
 
-void Nextion::fill_area(int x1, int y1, int width, int height, const char *color) {
+void Nextion::fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color) {
-  this->add_no_result_to_queue_with_printf_("fill_area", "fill %d,%d,%d,%d,%s", x1, y1, width, height, color);
+  this->add_no_result_to_queue_with_printf_("fill_area", "fill %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%s", x1,
+                                            y1, width, height, color);
 }
 
-void Nextion::fill_area(int x1, int y1, int width, int height, Color color) {
+void Nextion::fill_area(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color) {
-  this->add_no_result_to_queue_with_printf_("fill_area", "fill %d,%d,%d,%d,%d", x1, y1, width, height,
+  this->add_no_result_to_queue_with_printf_("fill_area",
-                                            display::ColorUtil::color_to_565(color));
+                                            "fill %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1, y1,
+                                            width, height, display::ColorUtil::color_to_565(color));
 }
 
-void Nextion::line(int x1, int y1, int x2, int y2, uint16_t color) {
+void Nextion::line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
-  this->add_no_result_to_queue_with_printf_("line", "line %d,%d,%d,%d,%" PRIu16, x1, y1, x2, y2, color);
+  this->add_no_result_to_queue_with_printf_("line", "line %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1,
+                                            y1, x2, y2, color);
 }
 
-void Nextion::line(int x1, int y1, int x2, int y2, const char *color) {
+void Nextion::line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, const char *color) {
-  this->add_no_result_to_queue_with_printf_("line", "line %d,%d,%d,%d,%s", x1, y1, x2, y2, color);
+  this->add_no_result_to_queue_with_printf_("line", "line %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%s", x1, y1,
+                                            x2, y2, color);
 }
 
-void Nextion::line(int x1, int y1, int x2, int y2, Color color) {
+void Nextion::line(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, Color color) {
-  this->add_no_result_to_queue_with_printf_("line", "line %d,%d,%d,%d,%d", x1, y1, x2, y2,
+  this->add_no_result_to_queue_with_printf_("line", "line %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1,
-                                            display::ColorUtil::color_to_565(color));
+                                            y1, x2, y2, display::ColorUtil::color_to_565(color));
 }
 
-void Nextion::rectangle(int x1, int y1, int width, int height, uint16_t color) {
+void Nextion::rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint16_t color) {
-  this->add_no_result_to_queue_with_printf_("draw", "draw %d,%d,%d,%d,%" PRIu16, x1, y1, x1 + width, y1 + height,
+  this->add_no_result_to_queue_with_printf_("draw", "draw %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1,
+                                            y1, static_cast<uint16_t>(x1 + width), static_cast<uint16_t>(y1 + height),
                                             color);
 }
 
-void Nextion::rectangle(int x1, int y1, int width, int height, const char *color) {
+void Nextion::rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, const char *color) {
-  this->add_no_result_to_queue_with_printf_("draw", "draw %d,%d,%d,%d,%s", x1, y1, x1 + width, y1 + height, color);
+  this->add_no_result_to_queue_with_printf_("draw", "draw %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%s", x1, y1,
+                                            static_cast<uint16_t>(x1 + width), static_cast<uint16_t>(y1 + height),
+                                            color);
 }
 
-void Nextion::rectangle(int x1, int y1, int width, int height, Color color) {
+void Nextion::rectangle(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, Color color) {
-  this->add_no_result_to_queue_with_printf_("draw", "draw %d,%d,%d,%d,%d", x1, y1, x1 + width, y1 + height,
+  this->add_no_result_to_queue_with_printf_("draw", "draw %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, x1,
+                                            y1, static_cast<uint16_t>(x1 + width), static_cast<uint16_t>(y1 + height),
                                             display::ColorUtil::color_to_565(color));
 }
 
-void Nextion::circle(int center_x, int center_y, int radius, uint16_t color) {
+void Nextion::circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color) {
-  this->add_no_result_to_queue_with_printf_("cir", "cir %d,%d,%d,%" PRIu16, center_x, center_y, radius, color);
+  this->add_no_result_to_queue_with_printf_("cir", "cir %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, center_x,
+                                            center_y, radius, color);
 }
 
-void Nextion::circle(int center_x, int center_y, int radius, const char *color) {
+void Nextion::circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color) {
-  this->add_no_result_to_queue_with_printf_("cir", "cir %d,%d,%d,%s", center_x, center_y, radius, color);
+  this->add_no_result_to_queue_with_printf_("cir", "cir %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%s", center_x, center_y,
+                                            radius, color);
 }
 
-void Nextion::circle(int center_x, int center_y, int radius, Color color) {
+void Nextion::circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color) {
-  this->add_no_result_to_queue_with_printf_("cir", "cir %d,%d,%d,%d", center_x, center_y, radius,
+  this->add_no_result_to_queue_with_printf_("cir", "cir %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, center_x,
-                                            display::ColorUtil::color_to_565(color));
+                                            center_y, radius, display::ColorUtil::color_to_565(color));
 }
 
-void Nextion::filled_circle(int center_x, int center_y, int radius, uint16_t color) {
+void Nextion::filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, uint16_t color) {
-  this->add_no_result_to_queue_with_printf_("cirs", "cirs %d,%d,%d,%" PRIu16, center_x, center_y, radius, color);
+  this->add_no_result_to_queue_with_printf_("cirs", "cirs %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, center_x,
+                                            center_y, radius, color);
 }
 
-void Nextion::filled_circle(int center_x, int center_y, int radius, const char *color) {
+void Nextion::filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, const char *color) {
-  this->add_no_result_to_queue_with_printf_("cirs", "cirs %d,%d,%d,%s", center_x, center_y, radius, color);
+  this->add_no_result_to_queue_with_printf_("cirs", "cirs %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%s", center_x, center_y,
+                                            radius, color);
 }
 
-void Nextion::filled_circle(int center_x, int center_y, int radius, Color color) {
+void Nextion::filled_circle(uint16_t center_x, uint16_t center_y, uint16_t radius, Color color) {
-  this->add_no_result_to_queue_with_printf_("cirs", "cirs %d,%d,%d,%d", center_x, center_y, radius,
+  this->add_no_result_to_queue_with_printf_("cirs", "cirs %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16, center_x,
-                                            display::ColorUtil::color_to_565(color));
+                                            center_y, radius, display::ColorUtil::color_to_565(color));
 }
 
-void Nextion::qrcode(int x1, int y1, const char *content, int size, uint16_t background_color,
+void Nextion::qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size, uint16_t background_color,
-                     uint16_t foreground_color, int logo_pic, uint8_t border_width) {
+                     uint16_t foreground_color, uint8_t logo_pic, uint8_t border_width) {
-  this->add_no_result_to_queue_with_printf_("qrcode", "qrcode %d,%d,%d,%d,%d,%d,%d,\"%s\"", x1, y1, size,
-                                            background_color, foreground_color, logo_pic, border_width, content);
-}
-
-void Nextion::qrcode(int x1, int y1, const char *content, int size, Color background_color, Color foreground_color,
-                     int logo_pic, uint8_t border_width) {
   this->add_no_result_to_queue_with_printf_(
-      "qrcode", "qrcode %d,%d,%d,%d,%d,%d,%d,\"%s\"", x1, y1, size, display::ColorUtil::color_to_565(background_color),
+      "qrcode", "qrcode %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu8 ",%" PRIu8 ",\"%s\"", x1,
-      display::ColorUtil::color_to_565(foreground_color), logo_pic, border_width, content);
+      y1, size, background_color, foreground_color, logo_pic, border_width, content);
+}
+
+void Nextion::qrcode(uint16_t x1, uint16_t y1, const char *content, uint16_t size, Color background_color,
+                     Color foreground_color, uint8_t logo_pic, uint8_t border_width) {
+  this->add_no_result_to_queue_with_printf_(
+      "qrcode", "qrcode %" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu16 ",%" PRIu8 ",%" PRIu8 ",\"%s\"", x1,
+      y1, size, display::ColorUtil::color_to_565(background_color), display::ColorUtil::color_to_565(foreground_color),
+      logo_pic, border_width, content);
 }
 
 void Nextion::set_nextion_rtc_time(ESPTime time) {

esphome/components/nextion/sensor/nextion_sensor.cpp

@@ -30,7 +30,7 @@ void NextionSensor::add_to_wave_buffer(float state) {
 }
 
 void NextionSensor::update() {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (this->wave_chan_id_ == UINT8_MAX) {
@@ -45,7 +45,7 @@ void NextionSensor::update() {
 }
 
 void NextionSensor::set_state(float state, bool publish, bool send_to_nextion) {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (std::isnan(state))

esphome/components/nextion/switch/nextion_switch.cpp

@@ -18,13 +18,13 @@ void NextionSwitch::process_bool(const std::string &variable_name, bool on) {
 }
 
 void NextionSwitch::update() {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
   this->nextion_->add_to_get_queue(this);
 }
 
 void NextionSwitch::set_state(bool state, bool publish, bool send_to_nextion) {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (send_to_nextion) {

esphome/components/nextion/text_sensor/nextion_textsensor.cpp

@@ -16,13 +16,13 @@ void NextionTextSensor::process_text(const std::string &variable_name, const std
 }
 
 void NextionTextSensor::update() {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
   this->nextion_->add_to_get_queue(this);
 }
 
 void NextionTextSensor::set_state(const std::string &state, bool publish, bool send_to_nextion) {
-  if (!this->nextion_->is_setup())
+  if (!this->nextion_->is_setup() || this->nextion_->is_updating())
     return;
 
   if (send_to_nextion) {

esphome/components/number/__init__.py

@@ -239,13 +239,14 @@ async def setup_number_core_(
             cg.add(trigger.set_max(template_))
         await automation.build_automation(trigger, [(float, "x")], conf)
 
-    if CONF_UNIT_OF_MEASUREMENT in config:
+    if (unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)) is not None:
-        cg.add(var.traits.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+        cg.add(var.traits.set_unit_of_measurement(unit_of_measurement))
-    if CONF_MQTT_ID in config:
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        cg.add(var.traits.set_device_class(device_class))
+
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
-    if CONF_DEVICE_CLASS in config:
-        cg.add(var.traits.set_device_class(config[CONF_DEVICE_CLASS]))
 
 
 async def register_number(
@@ -284,10 +285,10 @@ async def number_in_range_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(condition_id, template_arg, paren)
 
-    if CONF_ABOVE in config:
+    if (above := config.get(CONF_ABOVE)) is not None:
-        cg.add(var.set_min(config[CONF_ABOVE]))
+        cg.add(var.set_min(above))
-    if CONF_BELOW in config:
+    if (below := config.get(CONF_BELOW)) is not None:
-        cg.add(var.set_max(config[CONF_BELOW]))
+        cg.add(var.set_max(below))
 
     return var
 
@@ -391,14 +392,14 @@ async def number_set_to_code(config, action_id, template_arg, args):
 async def number_to_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    if CONF_OPERATION in config:
+    if (operation := config.get(CONF_OPERATION)) is not None:
-        to_ = await cg.templatable(config[CONF_OPERATION], args, NumberOperation)
+        to_ = await cg.templatable(operation, args, NumberOperation)
         cg.add(var.set_operation(to_))
-        if CONF_CYCLE in config:
+        if (cycle := config.get(CONF_CYCLE)) is not None:
-            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
+            template_ = await cg.templatable(cycle, args, bool)
-            cg.add(var.set_cycle(cycle_))
+            cg.add(var.set_cycle(template_))
-    if CONF_MODE in config:
+    if (mode := config.get(CONF_MODE)) is not None:
-        cg.add(var.set_operation(NUMBER_OPERATION_OPTIONS[config[CONF_MODE]]))
+        cg.add(var.set_operation(NUMBER_OPERATION_OPTIONS[mode]))
-        if CONF_CYCLE in config:
+        if (cycle := config.get(CONF_CYCLE)) is not None:
-            cg.add(var.set_cycle(config[CONF_CYCLE]))
+            cg.add(var.set_cycle(cycle))
     return var

esphome/components/psram/__init__.py

@@ -54,5 +54,7 @@ async def to_code(config):
         if CONF_SPEED in config:
             add_idf_sdkconfig_option(f"{SPIRAM_SPEEDS[config[CONF_SPEED]]}", True)
 
+    cg.add_define("USE_PSRAM")
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/remote_base/__init__.py

@@ -33,6 +33,9 @@ from esphome.const import (
     CONF_WAND_ID,
     CONF_LEVEL,
     CONF_DELTA,
+    CONF_ID,
+    CONF_BUTTON,
+    CONF_CHECK,
 )
 from esphome.core import coroutine
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
@@ -512,6 +515,57 @@ async def dish_action(var, config, args):
     cg.add(var.set_command(template_))
 
 
+# Dooya
+DooyaData, DooyaBinarySensor, DooyaTrigger, DooyaAction, DooyaDumper = declare_protocol(
+    "Dooya"
+)
+DOOYA_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_ID): cv.hex_int_range(0, 16777215),
+        cv.Required(CONF_CHANNEL): cv.hex_int_range(0, 255),
+        cv.Required(CONF_BUTTON): cv.hex_int_range(0, 15),
+        cv.Required(CONF_CHECK): cv.hex_int_range(0, 15),
+    }
+)
+
+
+@register_binary_sensor("dooya", DooyaBinarySensor, DOOYA_SCHEMA)
+def dooya_binary_sensor(var, config):
+    cg.add(
+        var.set_data(
+            cg.StructInitializer(
+                DooyaData,
+                ("id", config[CONF_ID]),
+                ("channel", config[CONF_CHANNEL]),
+                ("button", config[CONF_BUTTON]),
+                ("check", config[CONF_CHECK]),
+            )
+        )
+    )
+
+
+@register_trigger("dooya", DooyaTrigger, DooyaData)
+def dooya_trigger(var, config):
+    pass
+
+
+@register_dumper("dooya", DooyaDumper)
+def dooya_dumper(var, config):
+    pass
+
+
+@register_action("dooya", DooyaAction, DOOYA_SCHEMA)
+async def dooya_action(var, config, args):
+    template_ = await cg.templatable(config[CONF_ID], args, cg.uint32)
+    cg.add(var.set_id(template_))
+    template_ = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
+    cg.add(var.set_channel(template_))
+    template_ = await cg.templatable(config[CONF_BUTTON], args, cg.uint8)
+    cg.add(var.set_button(template_))
+    template_ = await cg.templatable(config[CONF_CHECK], args, cg.uint8)
+    cg.add(var.set_check(template_))
+
+
 # JVC
 JVCData, JVCBinarySensor, JVCTrigger, JVCAction, JVCDumper = declare_protocol("JVC")
 JVC_SCHEMA = cv.Schema({cv.Required(CONF_DATA): cv.hex_uint32_t})
@@ -827,6 +881,45 @@ async def pronto_action(var, config, args):
     cg.add(var.set_data(template_))
 
 
+# Roomba
+(
+    RoombaData,
+    RoombaBinarySensor,
+    RoombaTrigger,
+    RoombaAction,
+    RoombaDumper,
+) = declare_protocol("Roomba")
+ROOMBA_SCHEMA = cv.Schema({cv.Required(CONF_DATA): cv.hex_uint8_t})
+
+
+@register_binary_sensor("roomba", RoombaBinarySensor, ROOMBA_SCHEMA)
+def roomba_binary_sensor(var, config):
+    cg.add(
+        var.set_data(
+            cg.StructInitializer(
+                RoombaData,
+                ("data", config[CONF_DATA]),
+            )
+        )
+    )
+
+
+@register_trigger("roomba", RoombaTrigger, RoombaData)
+def roomba_trigger(var, config):
+    pass
+
+
+@register_dumper("roomba", RoombaDumper)
+def roomba_dumper(var, config):
+    pass
+
+
+@register_action("roomba", RoombaAction, ROOMBA_SCHEMA)
+async def roomba_action(var, config, args):
+    template_ = await cg.templatable(config[CONF_DATA], args, cg.uint8)
+    cg.add(var.set_data(template_))
+
+
 # Sony
 SonyData, SonyBinarySensor, SonyTrigger, SonyAction, SonyDumper = declare_protocol(
     "Sony"

esphome/components/remote_base/dooya_protocol.cpp

@@ -0,0 +1,120 @@
+#include "dooya_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.dooya";
+
+static const uint32_t HEADER_HIGH_US = 5000;
+static const uint32_t HEADER_LOW_US = 1500;
+static const uint32_t BIT_ZERO_HIGH_US = 750;
+static const uint32_t BIT_ZERO_LOW_US = 350;
+static const uint32_t BIT_ONE_HIGH_US = 350;
+static const uint32_t BIT_ONE_LOW_US = 750;
+
+void DooyaProtocol::encode(RemoteTransmitData *dst, const DooyaData &data) {
+  dst->set_carrier_frequency(0);
+  dst->reserve(2 + 40 * 2u);
+
+  dst->item(HEADER_HIGH_US, HEADER_LOW_US);
+
+  for (uint32_t mask = 1UL << (23); mask != 0; mask >>= 1) {
+    if (data.id & mask) {
+      dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+
+  for (uint32_t mask = 1UL << (7); mask != 0; mask >>= 1) {
+    if (data.channel & mask) {
+      dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+
+  for (uint32_t mask = 1UL << (3); mask != 0; mask >>= 1) {
+    if (data.button & mask) {
+      dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+
+  for (uint32_t mask = 1UL << (3); mask != 0; mask >>= 1) {
+    if (data.check & mask) {
+      dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+}
+optional<DooyaData> DooyaProtocol::decode(RemoteReceiveData src) {
+  DooyaData out{
+      .id = 0,
+      .channel = 0,
+      .button = 0,
+      .check = 0,
+  };
+  if (!src.expect_item(HEADER_HIGH_US, HEADER_LOW_US))
+    return {};
+
+  for (uint8_t i = 0; i < 24; i++) {
+    if (src.expect_item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US)) {
+      out.id = (out.id << 1) | 1;
+    } else if (src.expect_item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US)) {
+      out.id = (out.id << 1) | 0;
+    } else {
+      return {};
+    }
+  }
+
+  for (uint8_t i = 0; i < 8; i++) {
+    if (src.expect_item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US)) {
+      out.channel = (out.channel << 1) | 1;
+    } else if (src.expect_item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US)) {
+      out.channel = (out.channel << 1) | 0;
+    } else {
+      return {};
+    }
+  }
+
+  for (uint8_t i = 0; i < 4; i++) {
+    if (src.expect_item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US)) {
+      out.button = (out.button << 1) | 1;
+    } else if (src.expect_item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US)) {
+      out.button = (out.button << 1) | 0;
+    } else {
+      return {};
+    }
+  }
+
+  for (uint8_t i = 0; i < 3; i++) {
+    if (src.expect_item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US)) {
+      out.check = (out.check << 1) | 1;
+    } else if (src.expect_item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US)) {
+      out.check = (out.check << 1) | 0;
+    } else {
+      return {};
+    }
+  }
+  // Last bit is not received properly but can be decoded
+  if (src.expect_mark(BIT_ONE_HIGH_US)) {
+    out.check = (out.check << 1) | 1;
+  } else if (src.expect_mark(BIT_ZERO_HIGH_US)) {
+    out.check = (out.check << 1) | 0;
+  } else {
+    return {};
+  }
+
+  return out;
+}
+void DooyaProtocol::dump(const DooyaData &data) {
+  ESP_LOGI(TAG, "Received Dooya: id=0x%08" PRIX32 ", channel=%d, button=%d, check=%d", data.id, data.channel,
+           data.button, data.check);
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/dooya_protocol.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "remote_base.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace remote_base {
+
+struct DooyaData {
+  uint32_t id;
+  uint8_t channel;
+  uint8_t button;
+  uint8_t check;
+
+  bool operator==(const DooyaData &rhs) const {
+    return id == rhs.id && channel == rhs.channel && button == rhs.button && check == rhs.check;
+  }
+};
+
+class DooyaProtocol : public RemoteProtocol<DooyaData> {
+ public:
+  void encode(RemoteTransmitData *dst, const DooyaData &data) override;
+  optional<DooyaData> decode(RemoteReceiveData src) override;
+  void dump(const DooyaData &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(Dooya)
+
+template<typename... Ts> class DooyaAction : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint32_t, id)
+  TEMPLATABLE_VALUE(uint8_t, channel)
+  TEMPLATABLE_VALUE(uint8_t, button)
+  TEMPLATABLE_VALUE(uint8_t, check)
+
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    DooyaData data{};
+    data.id = this->id_.value(x...);
+    data.channel = this->channel_.value(x...);
+    data.button = this->button_.value(x...);
+    data.check = this->check_.value(x...);
+    DooyaProtocol().encode(dst, data);
+  }
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/roomba_protocol.cpp

@@ -0,0 +1,56 @@
+#include "roomba_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.roomba";
+
+static const uint8_t NBITS = 8;
+static const uint32_t BIT_ONE_HIGH_US = 3000;
+static const uint32_t BIT_ONE_LOW_US = 1000;
+static const uint32_t BIT_ZERO_HIGH_US = BIT_ONE_LOW_US;
+static const uint32_t BIT_ZERO_LOW_US = BIT_ONE_HIGH_US;
+
+void RoombaProtocol::encode(RemoteTransmitData *dst, const RoombaData &data) {
+  dst->set_carrier_frequency(38000);
+  dst->reserve(NBITS * 2u);
+
+  for (uint32_t mask = 1UL << (NBITS - 1); mask != 0; mask >>= 1) {
+    if (data.data & mask) {
+      dst->item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US);
+    } else {
+      dst->item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US);
+    }
+  }
+}
+optional<RoombaData> RoombaProtocol::decode(RemoteReceiveData src) {
+  RoombaData out{.data = 0};
+
+  for (uint8_t i = 0; i < (NBITS - 1); i++) {
+    out.data <<= 1UL;
+    if (src.expect_item(BIT_ONE_HIGH_US, BIT_ONE_LOW_US)) {
+      out.data |= 1UL;
+    } else if (src.expect_item(BIT_ZERO_HIGH_US, BIT_ZERO_LOW_US)) {
+      out.data |= 0UL;
+    } else {
+      return {};
+    }
+  }
+
+  // not possible to measure space on last bit, check only mark
+  out.data <<= 1UL;
+  if (src.expect_mark(BIT_ONE_HIGH_US)) {
+    out.data |= 1UL;
+  } else if (src.expect_mark(BIT_ZERO_HIGH_US)) {
+    out.data |= 0UL;
+  } else {
+    return {};
+  }
+
+  return out;
+}
+void RoombaProtocol::dump(const RoombaData &data) { ESP_LOGD(TAG, "Received Roomba: data=0x%02X", data.data); }
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/roomba_protocol.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "remote_base.h"
+
+namespace esphome {
+namespace remote_base {
+
+struct RoombaData {
+  uint8_t data;
+
+  bool operator==(const RoombaData &rhs) const { return data == rhs.data; }
+};
+
+class RoombaProtocol : public RemoteProtocol<RoombaData> {
+ public:
+  void encode(RemoteTransmitData *dst, const RoombaData &data) override;
+  optional<RoombaData> decode(RemoteReceiveData src) override;
+  void dump(const RoombaData &data) override;
+};
+
+DECLARE_REMOTE_PROTOCOL(Roomba)
+
+template<typename... Ts> class RoombaAction : public RemoteTransmitterActionBase<Ts...> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, data)
+
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    RoombaData data{};
+    data.data = this->data_.value(x...);
+    RoombaProtocol().encode(dst, data);
+  }
+};
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/select/__init__.py

@@ -95,8 +95,8 @@ async def setup_select_core_(var, config, *, options: list[str]):
             trigger, [(cg.std_string, "x"), (cg.size_t, "i")], conf
         )
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
 
@@ -223,14 +223,14 @@ async def select_set_index_to_code(config, action_id, template_arg, args):
 async def select_operation_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, paren)
-    if CONF_OPERATION in config:
+    if (operation := config.get(CONF_OPERATION)) is not None:
-        op_ = await cg.templatable(config[CONF_OPERATION], args, SelectOperation)
+        op_ = await cg.templatable(operation, args, SelectOperation)
         cg.add(var.set_operation(op_))
-        if CONF_CYCLE in config:
+        if (cycle := config.get(CONF_CYCLE)) is not None:
-            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
+            template_ = await cg.templatable(cycle, args, bool)
-            cg.add(var.set_cycle(cycle_))
+            cg.add(var.set_cycle(template_))
-    if CONF_MODE in config:
+    if (mode := config.get(CONF_MODE)) is not None:
-        cg.add(var.set_operation(SELECT_OPERATION_OPTIONS[config[CONF_MODE]]))
+        cg.add(var.set_operation(SELECT_OPERATION_OPTIONS[mode]))
-        if CONF_CYCLE in config:
+        if (cycle := config.get(CONF_CYCLE)) is not None:
-            cg.add(var.set_cycle(config[CONF_CYCLE]))
+            cg.add(var.set_cycle(cycle))
     return var

esphome/components/select/select.cpp

@@ -12,7 +12,7 @@ void Select::publish_state(const std::string &state) {
   if (index.has_value()) {
     this->has_state_ = true;
     this->state = state;
-    ESP_LOGD(TAG, "'%s': Sending state %s (index %d)", name, state.c_str(), index.value());
+    ESP_LOGD(TAG, "'%s': Sending state %s (index %zu)", name, state.c_str(), index.value());
     this->state_callback_.call(state, index.value());
   } else {
     ESP_LOGE(TAG, "'%s': invalid state for publish_state(): %s", name, state.c_str());

esphome/components/select/select_call.cpp

@@ -71,7 +71,7 @@ void SelectCall::perform() {
       return;
     }
     if (this->index_.value() >= options.size()) {
-      ESP_LOGW(TAG, "'%s' - Index value %d out of bounds", name, this->index_.value());
+      ESP_LOGW(TAG, "'%s' - Index value %zu out of bounds", name, this->index_.value());
       return;
     }
     target_value = options[this->index_.value()];

esphome/components/sensor/__init__.py

@@ -732,14 +732,14 @@ async def build_filters(config):
 async def setup_sensor_core_(var, config):
     await setup_entity(var, config)
 
-    if CONF_DEVICE_CLASS in config:
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+        cg.add(var.set_device_class(device_class))
-    if CONF_STATE_CLASS in config:
+    if (state_class := config.get(CONF_STATE_CLASS)) is not None:
-        cg.add(var.set_state_class(config[CONF_STATE_CLASS]))
+        cg.add(var.set_state_class(state_class))
-    if CONF_UNIT_OF_MEASUREMENT in config:
+    if (unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)) is not None:
-        cg.add(var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+        cg.add(var.set_unit_of_measurement(unit_of_measurement))
-    if CONF_ACCURACY_DECIMALS in config:
+    if (accuracy_decimals := config.get(CONF_ACCURACY_DECIMALS)) is not None:
-        cg.add(var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+        cg.add(var.set_accuracy_decimals(accuracy_decimals))
     cg.add(var.set_force_update(config[CONF_FORCE_UPDATE]))
     if config.get(CONF_FILTERS):  # must exist and not be empty
         filters = await build_filters(config[CONF_FILTERS])
@@ -754,23 +754,23 @@ async def setup_sensor_core_(var, config):
     for conf in config.get(CONF_ON_VALUE_RANGE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await cg.register_component(trigger, conf)
-        if CONF_ABOVE in conf:
+        if (above := conf.get(CONF_ABOVE)) is not None:
-            template_ = await cg.templatable(conf[CONF_ABOVE], [(float, "x")], float)
+            template_ = await cg.templatable(above, [(float, "x")], float)
             cg.add(trigger.set_min(template_))
-        if CONF_BELOW in conf:
+        if (below := conf.get(CONF_BELOW)) is not None:
-            template_ = await cg.templatable(conf[CONF_BELOW], [(float, "x")], float)
+            template_ = await cg.templatable(below, [(float, "x")], float)
             cg.add(trigger.set_max(template_))
         await automation.build_automation(trigger, [(float, "x")], conf)
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-        if CONF_EXPIRE_AFTER in config:
+        if (expire_after := config.get(CONF_EXPIRE_AFTER, _UNDEF)) is not _UNDEF:
-            if config[CONF_EXPIRE_AFTER] is None:
+            if expire_after is None:
                 cg.add(mqtt_.disable_expire_after())
             else:
-                cg.add(mqtt_.set_expire_after(config[CONF_EXPIRE_AFTER]))
+                cg.add(mqtt_.set_expire_after(expire_after))
 
 
 async def register_sensor(var, config):
@@ -803,10 +803,10 @@ async def sensor_in_range_to_code(config, condition_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(condition_id, template_arg, paren)
 
-    if CONF_ABOVE in config:
+    if (above := config.get(CONF_ABOVE)) is not None:
-        cg.add(var.set_min(config[CONF_ABOVE]))
+        cg.add(var.set_min(above))
-    if CONF_BELOW in config:
+    if (below := config.get(CONF_BELOW)) is not None:
-        cg.add(var.set_max(config[CONF_BELOW]))
+        cg.add(var.set_max(below))
 
     return var
 

esphome/components/sensor/filter.cpp

@@ -79,7 +79,7 @@ SkipInitialFilter::SkipInitialFilter(size_t num_to_ignore) : num_to_ignore_(num_
 optional<float> SkipInitialFilter::new_value(float value) {
   if (num_to_ignore_ > 0) {
     num_to_ignore_--;
-    ESP_LOGV(TAG, "SkipInitialFilter(%p)::new_value(%f) SKIPPING, %u left", this, value, num_to_ignore_);
+    ESP_LOGV(TAG, "SkipInitialFilter(%p)::new_value(%f) SKIPPING, %zu left", this, value, num_to_ignore_);
     return {};
   }
 
@@ -359,11 +359,15 @@ OrFilter::OrFilter(std::vector<Filter *> filters) : filters_(std::move(filters))
 OrFilter::PhiNode::PhiNode(OrFilter *or_parent) : or_parent_(or_parent) {}
 
 optional<float> OrFilter::PhiNode::new_value(float value) {
+  if (!this->or_parent_->has_value_) {
     this->or_parent_->output(value);
+    this->or_parent_->has_value_ = true;
+  }
 
   return {};
 }
 optional<float> OrFilter::new_value(float value) {
+  this->has_value_ = false;
   for (Filter *filter : this->filters_)
     filter->input(value);
 

esphome/components/sensor/filter.h

@@ -388,6 +388,7 @@ class OrFilter : public Filter {
   };
 
   std::vector<Filter *> filters_;
+  bool has_value_{false};
   PhiNode phi_;
 };
 

esphome/components/sht3xd/sht3xd.cpp

@@ -6,9 +6,14 @@ namespace sht3xd {
 
 static const char *const TAG = "sht3xd";
 
-// use read serial number register with clock stretching disabled as per other SHT3XD_COMMAND registers
+// https://sensirion.com/media/documents/E5762713/63D103C2/Sensirion_electronic_identification_code_SHT3x.pdf
-// which provides support for SHT85 sensor
+// indicates two possible read serial number registers either with clock stretching enabled or disabled.
-// SHT85 does not support clock stretching and uses same registers as SHT3xd with clock stretching disabled
+// Other SHT3XD_COMMAND registers use the clock stretching disabled register.
+// To ensure compatibility, reading serial number using the register with clock stretching register enabled
+// (used originally in this component) is tried first and if that fails the alternate register address
+// with clock stretching disabled is read.
+
+static const uint16_t SHT3XD_COMMAND_READ_SERIAL_NUMBER_CLOCK_STRETCHING = 0x3780;
 static const uint16_t SHT3XD_COMMAND_READ_SERIAL_NUMBER = 0x3682;
 
 static const uint16_t SHT3XD_COMMAND_READ_STATUS = 0xF32D;
@@ -22,13 +27,19 @@ static const uint16_t SHT3XD_COMMAND_FETCH_DATA = 0xE000;
 void SHT3XDComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up SHT3xD...");
   uint16_t raw_serial_number[2];
+  if (!this->get_register(SHT3XD_COMMAND_READ_SERIAL_NUMBER_CLOCK_STRETCHING, raw_serial_number, 2)) {
+    this->error_code_ = READ_SERIAL_STRETCHED_FAILED;
     if (!this->get_register(SHT3XD_COMMAND_READ_SERIAL_NUMBER, raw_serial_number, 2)) {
+      this->error_code_ = READ_SERIAL_FAILED;
       this->mark_failed();
       return;
     }
+  }
+
   this->serial_number_ = (uint32_t(raw_serial_number[0]) << 16) | uint32_t(raw_serial_number[1]);
 
   if (!this->write_command(heater_enabled_ ? SHT3XD_COMMAND_HEATER_ENABLE : SHT3XD_COMMAND_HEATER_DISABLE)) {
+    this->error_code_ = WRITE_HEATER_MODE_FAILED;
     this->mark_failed();
     return;
   }
@@ -36,10 +47,21 @@ void SHT3XDComponent::setup() {
 
 void SHT3XDComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SHT3xD:");
+  switch (this->error_code_) {
+    case READ_SERIAL_FAILED:
+      ESP_LOGD(TAG, "  Error reading serial number");
+      break;
+    case WRITE_HEATER_MODE_FAILED:
+      ESP_LOGD(TAG, "  Error writing heater mode");
+      break;
+    default:
+      break;
+  }
   if (this->is_failed()) {
     ESP_LOGE(TAG, "  Communication with SHT3xD failed!");
     return;
   }
+  ESP_LOGD(TAG, "  Setup successful");
   ESP_LOGD(TAG, "  Serial Number: 0x%08" PRIX32, this->serial_number_);
   ESP_LOGD(TAG, "  Heater Enabled: %s", this->heater_enabled_ ? "true" : "false");
 

esphome/components/sht3xd/sht3xd.h

@@ -22,6 +22,13 @@ class SHT3XDComponent : public PollingComponent, public sensirion_common::Sensir
   void set_heater_enabled(bool heater_enabled) { heater_enabled_ = heater_enabled; }
 
  protected:
+  enum ErrorCode {
+    NONE = 0,
+    READ_SERIAL_STRETCHED_FAILED,
+    READ_SERIAL_FAILED,
+    WRITE_HEATER_MODE_FAILED,
+  } error_code_{NONE};
+
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *humidity_sensor_{nullptr};
   bool heater_enabled_{true};

esphome/components/sm2135/sm2135.cpp

@@ -106,23 +106,23 @@ void SM2135::loop() {
       delay(1);
       this->sm2135_start_();
       this->write_byte_(SM2135_ADDR_C);
-      this->write_byte_(this->pwm_amounts_[4]);  // Warm
+      this->write_byte_(this->pwm_amounts_[3]);
-      this->write_byte_(this->pwm_amounts_[3]);  // Cold
+      this->write_byte_(this->pwm_amounts_[4]);
     } else {
       // Color
 
       this->write_byte_(SM2135_RGB);
-      this->write_byte_(this->pwm_amounts_[1]);  // Green
+      this->write_byte_(this->pwm_amounts_[0]);
-      this->write_byte_(this->pwm_amounts_[0]);  // Red
+      this->write_byte_(this->pwm_amounts_[1]);
-      this->write_byte_(this->pwm_amounts_[2]);  // Blue
+      this->write_byte_(this->pwm_amounts_[2]);
     }
   } else {
     this->write_byte_(SM2135_RGB);
-    this->write_byte_(this->pwm_amounts_[1]);  // Green
+    this->write_byte_(this->pwm_amounts_[0]);
-    this->write_byte_(this->pwm_amounts_[0]);  // Red
+    this->write_byte_(this->pwm_amounts_[1]);
-    this->write_byte_(this->pwm_amounts_[2]);  // Blue
+    this->write_byte_(this->pwm_amounts_[2]);
-    this->write_byte_(this->pwm_amounts_[4]);  // Warm
+    this->write_byte_(this->pwm_amounts_[3]);
-    this->write_byte_(this->pwm_amounts_[3]);  // Cold
+    this->write_byte_(this->pwm_amounts_[4]);
   }
 
   this->sm2135_stop_();

esphome/components/sn74hc595/__init__.py

@@ -4,14 +4,13 @@ from esphome import pins
 from esphome.components import spi
 from esphome.const import (
     CONF_ID,
-    CONF_SPI_ID,
     CONF_NUMBER,
     CONF_INVERTED,
     CONF_DATA_PIN,
     CONF_CLOCK_PIN,
     CONF_OUTPUT,
+    CONF_TYPE,
 )
-from esphome.core import EsphomeError
 
 MULTI_CONF = True
 
@@ -34,53 +33,53 @@ CONF_LATCH_PIN = "latch_pin"
 CONF_OE_PIN = "oe_pin"
 CONF_SR_COUNT = "sr_count"
 
-CONFIG_SCHEMA = cv.Any(
+TYPE_GPIO = "gpio"
-    cv.Schema(
+TYPE_SPI = "spi"
+
+_COMMON_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_LATCH_PIN): pins.gpio_output_pin_schema,
+        cv.Optional(CONF_OE_PIN): pins.gpio_output_pin_schema,
+        cv.Optional(CONF_SR_COUNT, default=1): cv.int_range(min=1, max=256),
+    }
+)
+
+CONFIG_SCHEMA = cv.typed_schema(
+    {
+        TYPE_GPIO: _COMMON_SCHEMA.extend(
             {
                 cv.Required(CONF_ID): cv.declare_id(SN74HC595GPIOComponent),
                 cv.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema,
                 cv.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_LATCH_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_OE_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_SR_COUNT, default=1): cv.int_range(min=1, max=256),
             }
         ).extend(cv.COMPONENT_SCHEMA),
-    cv.Schema(
+        TYPE_SPI: _COMMON_SCHEMA.extend(
             {
                 cv.Required(CONF_ID): cv.declare_id(SN74HC595SPIComponent),
-            cv.Required(CONF_LATCH_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_OE_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_SR_COUNT, default=1): cv.int_range(min=1, max=256),
             }
         )
         .extend(cv.COMPONENT_SCHEMA)
-    .extend(spi.spi_device_schema(cs_pin_required=False))
+        .extend(spi.spi_device_schema(cs_pin_required=False)),
-    .extend(
+    },
-        {
+    default_type=TYPE_GPIO,
-            cv.Required(CONF_SPI_ID): cv.use_id(spi.SPIComponent),
-        }
-    ),
-    msg='Either "data_pin" and "clock_pin" must be set or "spi_id" must be set.',
 )
 
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    if CONF_DATA_PIN in config:
+    if config[CONF_TYPE] == TYPE_GPIO:
         data_pin = await cg.gpio_pin_expression(config[CONF_DATA_PIN])
         cg.add(var.set_data_pin(data_pin))
         clock_pin = await cg.gpio_pin_expression(config[CONF_CLOCK_PIN])
         cg.add(var.set_clock_pin(clock_pin))
-    elif CONF_SPI_ID in config:
-        await spi.register_spi_device(var, config)
     else:
-        raise EsphomeError("Not supported")
+        await spi.register_spi_device(var, config)
 
     latch_pin = await cg.gpio_pin_expression(config[CONF_LATCH_PIN])
     cg.add(var.set_latch_pin(latch_pin))
-    if CONF_OE_PIN in config:
+    if oe_pin := config.get(CONF_OE_PIN):
-        oe_pin = await cg.gpio_pin_expression(config[CONF_OE_PIN])
+        oe_pin = await cg.gpio_pin_expression(oe_pin)
         cg.add(var.set_oe_pin(oe_pin))
     cg.add(var.set_sr_count(config[CONF_SR_COUNT]))
 

esphome/components/switch/__init__.py

@@ -138,8 +138,8 @@ SWITCH_SCHEMA = switch_schema()  # for compatibility
 async def setup_switch_core_(var, config):
     await setup_entity(var, config)
 
-    if CONF_INVERTED in config:
+    if (inverted := config.get(CONF_INVERTED)) is not None:
-        cg.add(var.set_inverted(config[CONF_INVERTED]))
+        cg.add(var.set_inverted(inverted))
     for conf in config.get(CONF_ON_TURN_ON, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
@@ -147,12 +147,12 @@ async def setup_switch_core_(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
-    if CONF_MQTT_ID in config:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-    if CONF_DEVICE_CLASS in config:
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+        cg.add(var.set_device_class(device_class))
 
     cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
 

esphome/components/template/event/__init__.py

@@ -0,0 +1,24 @@
+import esphome.config_validation as cv
+
+from esphome.components import event
+
+import esphome.codegen as cg
+
+from esphome.const import CONF_EVENT_TYPES
+
+from .. import template_ns
+
+CODEOWNERS = ["@nohat"]
+
+TemplateEvent = template_ns.class_("TemplateEvent", event.Event, cg.Component)
+
+CONFIG_SCHEMA = event.event_schema(TemplateEvent).extend(
+    {
+        cv.Required(CONF_EVENT_TYPES): cv.ensure_list(cv.string_strict),
+    }
+)
+
+
+async def to_code(config):
+    var = await event.new_event(config, event_types=config[CONF_EVENT_TYPES])
+    await cg.register_component(var, config)

esphome/components/template/event/template_event.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/event/event.h"
+
+namespace esphome {
+namespace template_ {
+
+class TemplateEvent : public Component, public event::Event {};
+
+}  // namespace template_
+}  // namespace esphome

esphome/components/template/valve/__init__.py

@@ -0,0 +1,118 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.components import valve
+from esphome.const import (
+    CONF_ASSUMED_STATE,
+    CONF_CLOSE_ACTION,
+    CONF_CURRENT_OPERATION,
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_OPEN_ACTION,
+    CONF_OPTIMISTIC,
+    CONF_POSITION,
+    CONF_POSITION_ACTION,
+    CONF_RESTORE_MODE,
+    CONF_STATE,
+    CONF_STOP_ACTION,
+)
+from .. import template_ns
+
+TemplateValve = template_ns.class_("TemplateValve", valve.Valve, cg.Component)
+
+TemplateValveRestoreMode = template_ns.enum("TemplateValveRestoreMode")
+RESTORE_MODES = {
+    "NO_RESTORE": TemplateValveRestoreMode.VALVE_NO_RESTORE,
+    "RESTORE": TemplateValveRestoreMode.VALVE_RESTORE,
+    "RESTORE_AND_CALL": TemplateValveRestoreMode.VALVE_RESTORE_AND_CALL,
+}
+
+CONF_HAS_POSITION = "has_position"
+CONF_TOGGLE_ACTION = "toggle_action"
+
+CONFIG_SCHEMA = valve.VALVE_SCHEMA.extend(
+    {
+        cv.GenerateID(): cv.declare_id(TemplateValve),
+        cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+        cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
+        cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
+        cv.Optional(CONF_HAS_POSITION, default=False): cv.boolean,
+        cv.Optional(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+        cv.Optional(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+        cv.Optional(CONF_STOP_ACTION): automation.validate_automation(single=True),
+        cv.Optional(CONF_TOGGLE_ACTION): automation.validate_automation(single=True),
+        cv.Optional(CONF_POSITION_ACTION): automation.validate_automation(single=True),
+        cv.Optional(CONF_RESTORE_MODE, default="NO_RESTORE"): cv.enum(
+            RESTORE_MODES, upper=True
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = await valve.new_valve(config)
+    await cg.register_component(var, config)
+    if lambda_config := config.get(CONF_LAMBDA):
+        template_ = await cg.process_lambda(
+            lambda_config, [], return_type=cg.optional.template(float)
+        )
+        cg.add(var.set_state_lambda(template_))
+    if open_action_config := config.get(CONF_OPEN_ACTION):
+        await automation.build_automation(
+            var.get_open_trigger(), [], open_action_config
+        )
+    if close_action_config := config.get(CONF_CLOSE_ACTION):
+        await automation.build_automation(
+            var.get_close_trigger(), [], close_action_config
+        )
+    if stop_action_config := config.get(CONF_STOP_ACTION):
+        await automation.build_automation(
+            var.get_stop_trigger(), [], stop_action_config
+        )
+        cg.add(var.set_has_stop(True))
+    if toggle_action_config := config.get(CONF_TOGGLE_ACTION):
+        await automation.build_automation(
+            var.get_toggle_trigger(), [], toggle_action_config
+        )
+        cg.add(var.set_has_toggle(True))
+    if position_action_config := config.get(CONF_POSITION_ACTION):
+        await automation.build_automation(
+            var.get_position_trigger(), [(float, "pos")], position_action_config
+        )
+        cg.add(var.set_has_position(True))
+    else:
+        cg.add(var.set_has_position(config[CONF_HAS_POSITION]))
+    cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+    cg.add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
+    cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
+
+
+@automation.register_action(
+    "valve.template.publish",
+    valve.ValvePublishAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(valve.Valve),
+            cv.Exclusive(CONF_STATE, "pos"): cv.templatable(valve.validate_valve_state),
+            cv.Exclusive(CONF_POSITION, "pos"): cv.templatable(cv.percentage),
+            cv.Optional(CONF_CURRENT_OPERATION): cv.templatable(
+                valve.validate_valve_operation
+            ),
+        }
+    ),
+)
+async def valve_template_publish_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    if state_config := config.get(CONF_STATE):
+        template_ = await cg.templatable(state_config, args, float)
+        cg.add(var.set_position(template_))
+    if (position_config := config.get(CONF_POSITION)) is not None:
+        template_ = await cg.templatable(position_config, args, float)
+        cg.add(var.set_position(template_))
+    if current_operation_config := config.get(CONF_CURRENT_OPERATION):
+        template_ = await cg.templatable(
+            current_operation_config, args, valve.ValveOperation
+        )
+        cg.add(var.set_current_operation(template_))
+    return var