Merge branch 'dev' into add-graphical-layout-system

.github/workflows/ci-docker.yml

@@ -46,7 +46,7 @@ jobs:
         with:
           python-version: "3.9"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.2.0
+        uses: docker/setup-buildx-action@v3.3.0
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3.0.0
 

.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
-            TAG="${GITHUB_REF#refs/tags/}"
+          if [[ "${{ github.event_name }}" = "release" ]]; then
+            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: |
-          script/setup
-          pip install twine
+        run: script/setup
       - name: Build
         run: python setup.py sdist bdist_wheel
-      - name: Upload
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
-        run: twine upload dist/*
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@v1.8.14
 
   deploy-docker:
     name: Build ESPHome ${{ matrix.platform }}
@@ -84,7 +88,7 @@ jobs:
           python-version: "3.9"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.2.0
+        uses: docker/setup-buildx-action@v3.3.0
       - name: Set up QEMU
         if: matrix.platform != 'linux/amd64'
         uses: docker/setup-qemu-action@v3.0.0
@@ -162,7 +166,7 @@ jobs:
           name: digests-${{ matrix.image.target }}-${{ matrix.registry }}
           path: /tmp/digests
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3.2.0
+        uses: docker/setup-buildx-action@v3.3.0
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'
@@ -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 }}",
-                content: ${{ toJSON(github.event.release.body) }}
+                version: "${{ needs.init.outputs.tag }}",
+                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.3
         with:
           commit-message: "Synchronise Device Classes from Home Assistant"
           committer: esphomebot <esphome@nabucasa.com>

.pre-commit-config.yaml

@@ -27,7 +27,7 @@ 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]

CODEOWNERS

@@ -91,7 +91,7 @@ esphome/components/daikin_arc/* @MagicBear
 esphome/components/daikin_brc/* @hagak
 esphome/components/daly_bms/* @s1lvi0
 esphome/components/dashboard_import/* @esphome/core
-esphome/components/datetime/* @rfdarter
+esphome/components/datetime/* @jesserockz @rfdarter
 esphome/components/debug/* @OttoWinter
 esphome/components/delonghi/* @grob6000
 esphome/components/dfplayer/* @glmnet
@@ -115,6 +115,7 @@ esphome/components/esp32_ble_server/* @Rapsssito @clydebarrow @jesserockz
 esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_improv/* @jesserockz
+esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
 esphome/components/ethernet_info/* @gtjadsonsantos
@@ -364,6 +365,7 @@ 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
@@ -405,6 +407,7 @@ esphome/components/wireguard/* @droscy @lhoracek @thomas0bernard
 esphome/components/wl_134/* @hobbypunk90
 esphome/components/x9c/* @EtienneMD
 esphome/components/xgzp68xx/* @gcormier
+esphome/components/xiaomi_hhccjcy10/* @fariouche
 esphome/components/xiaomi_lywsd03mmc/* @ahpohl
 esphome/components/xiaomi_mhoc303/* @drug123
 esphome/components/xiaomi_mhoc401/* @vevsvevs

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;
-  switch (sensor->get_gain()) {
+  float divider = (resolution == ADS1115_16_BITS) ? 32768.0f : 2048.0f;
+  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], paren)
+    var = cg.new_Pvariable(config[CONF_ID])
     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

@@ -45,6 +45,7 @@ service APIConnection {
   rpc lock_command (LockCommandRequest) returns (void) {}
   rpc media_player_command (MediaPlayerCommandRequest) returns (void) {}
   rpc date_command (DateCommandRequest) returns (void) {}
+  rpc time_command (TimeCommandRequest) returns (void) {}
 
   rpc subscribe_bluetooth_le_advertisements(SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
   rpc bluetooth_device_request(BluetoothDeviceRequest) returns (void) {}
@@ -217,7 +218,8 @@ message DeviceInfoResponse {
 
   string friendly_name = 13;
 
-  uint32 voice_assistant_version = 14;
+  uint32 legacy_voice_assistant_version = 14;
+  uint32 voice_assistant_feature_flags = 17;
 
   string suggested_area = 16;
 }
@@ -1422,12 +1424,18 @@ message BluetoothDeviceClearCacheResponse {
 }
 
 // ==================== PUSH TO TALK ====================
+enum VoiceAssistantSubscribeFlag {
+  VOICE_ASSISTANT_SUBSCRIBE_NONE = 0;
+  VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO = 1;
+}
+
 message SubscribeVoiceAssistantRequest {
   option (id) = 89;
   option (source) = SOURCE_CLIENT;
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
   bool subscribe = 1;
+  uint32 flags = 2;
 }
 
 enum VoiceAssistantRequestFlag {
@@ -1495,6 +1503,16 @@ message VoiceAssistantEventResponse {
   repeated VoiceAssistantEventData data = 2;
 }
 
+message VoiceAssistantAudio {
+  option (id) = 106;
+  option (source) = SOURCE_BOTH;
+  option (ifdef) = "USE_VOICE_ASSISTANT";
+
+  bytes data = 1;
+  bool end = 2;
+}
+
+
 // ==================== ALARM CONTROL PANEL ====================
 enum AlarmControlPanelState {
   ALARM_STATE_DISARMED = 0;
@@ -1641,3 +1659,44 @@ message DateCommandRequest {
   uint32 month = 3;
   uint32 day = 4;
 }
+
+// ==================== DATETIME TIME ====================
+message ListEntitiesTimeResponse {
+  option (id) = 103;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_DATETIME_TIME";
+
+  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;
+}
+message TimeStateResponse {
+  option (id) = 104;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_DATETIME_TIME";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  // If the time does not have a valid state yet.
+  // Equivalent to `!obj->has_state()` - inverse logic to make state packets smaller
+  bool missing_state = 2;
+  uint32 hour = 3;
+  uint32 minute = 4;
+  uint32 second = 5;
+}
+message TimeCommandRequest {
+  option (id) = 105;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_DATETIME_TIME";
+  option (no_delay) = true;
+
+  fixed32 key = 1;
+  uint32 hour = 2;
+  uint32 minute = 3;
+  uint32 second = 4;
+}

esphome/components/api/api_connection.cpp

@@ -735,6 +735,43 @@ void APIConnection::date_command(const DateCommandRequest &msg) {
 }
 #endif
 
+#ifdef USE_DATETIME_TIME
+bool APIConnection::send_time_state(datetime::TimeEntity *time) {
+  if (!this->state_subscription_)
+    return false;
+
+  TimeStateResponse resp{};
+  resp.key = time->get_object_id_hash();
+  resp.missing_state = !time->has_state();
+  resp.hour = time->hour;
+  resp.minute = time->minute;
+  resp.second = time->second;
+  return this->send_time_state_response(resp);
+}
+bool APIConnection::send_time_info(datetime::TimeEntity *time) {
+  ListEntitiesTimeResponse msg;
+  msg.key = time->get_object_id_hash();
+  msg.object_id = time->get_object_id();
+  if (time->has_own_name())
+    msg.name = time->get_name();
+  msg.unique_id = get_default_unique_id("time", time);
+  msg.icon = time->get_icon();
+  msg.disabled_by_default = time->is_disabled_by_default();
+  msg.entity_category = static_cast<enums::EntityCategory>(time->get_entity_category());
+
+  return this->send_list_entities_time_response(msg);
+}
+void APIConnection::time_command(const TimeCommandRequest &msg) {
+  datetime::TimeEntity *time = App.get_time_by_key(msg.key);
+  if (time == nullptr)
+    return;
+
+  auto call = time->make_call();
+  call.set_time(msg.hour, msg.minute, msg.second);
+  call.perform();
+}
+#endif
+
 #ifdef USE_TEXT
 bool APIConnection::send_text_state(text::Text *text, std::string state) {
   if (!this->state_subscription_)
@@ -1040,10 +1077,15 @@ void APIConnection::on_voice_assistant_response(const VoiceAssistantResponse &ms
       voice_assistant::global_voice_assistant->failed_to_start();
       return;
     }
-    struct sockaddr_storage storage;
-    socklen_t len = sizeof(storage);
-    this->helper_->getpeername((struct sockaddr *) &storage, &len);
-    voice_assistant::global_voice_assistant->start_streaming(&storage, msg.port);
+    if (msg.port == 0) {
+      // Use API Audio
+      voice_assistant::global_voice_assistant->start_streaming();
+    } else {
+      struct sockaddr_storage storage;
+      socklen_t len = sizeof(storage);
+      this->helper_->getpeername((struct sockaddr *) &storage, &len);
+      voice_assistant::global_voice_assistant->start_streaming(&storage, msg.port);
+    }
   }
 };
 void APIConnection::on_voice_assistant_event_response(const VoiceAssistantEventResponse &msg) {
@@ -1055,6 +1097,15 @@ void APIConnection::on_voice_assistant_event_response(const VoiceAssistantEventR
     voice_assistant::global_voice_assistant->on_event(msg);
   }
 }
+void APIConnection::on_voice_assistant_audio(const VoiceAssistantAudio &msg) {
+  if (voice_assistant::global_voice_assistant != nullptr) {
+    if (voice_assistant::global_voice_assistant->get_api_connection() != this) {
+      return;
+    }
+
+    voice_assistant::global_voice_assistant->on_audio(msg);
+  }
+};
 
 #endif
 
@@ -1142,7 +1193,7 @@ HelloResponse APIConnection::hello(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 9;
+  resp.api_version_minor = 10;
   resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
   resp.name = App.get_name();
 
@@ -1203,7 +1254,8 @@ DeviceInfoResponse APIConnection::device_info(const DeviceInfoRequest &msg) {
   resp.bluetooth_proxy_feature_flags = bluetooth_proxy::global_bluetooth_proxy->get_feature_flags();
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  resp.voice_assistant_version = voice_assistant::global_voice_assistant->get_version();
+  resp.legacy_voice_assistant_version = voice_assistant::global_voice_assistant->get_legacy_version();
+  resp.voice_assistant_feature_flags = voice_assistant::global_voice_assistant->get_feature_flags();
 #endif
   return resp;
 }

esphome/components/api/api_connection.h

@@ -77,6 +77,11 @@ class APIConnection : public APIServerConnection {
   bool send_date_info(datetime::DateEntity *date);
   void date_command(const DateCommandRequest &msg) override;
 #endif
+#ifdef USE_DATETIME_TIME
+  bool send_time_state(datetime::TimeEntity *time);
+  bool send_time_info(datetime::TimeEntity *time);
+  void time_command(const TimeCommandRequest &msg) override;
+#endif
 #ifdef USE_TEXT
   bool send_text_state(text::Text *text, std::string state);
   bool send_text_info(text::Text *text);
@@ -134,6 +139,7 @@ class APIConnection : public APIServerConnection {
   void subscribe_voice_assistant(const SubscribeVoiceAssistantRequest &msg) override;
   void on_voice_assistant_response(const VoiceAssistantResponse &msg) override;
   void on_voice_assistant_event_response(const VoiceAssistantEventResponse &msg) override;
+  void on_voice_assistant_audio(const VoiceAssistantAudio &msg) override;
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL

esphome/components/api/api_pb2.cpp

@@ -410,6 +410,19 @@ const char *proto_enum_to_string<enums::BluetoothDeviceRequestType>(enums::Bluet
 }
 #endif
 #ifdef HAS_PROTO_MESSAGE_DUMP
+template<>
+const char *proto_enum_to_string<enums::VoiceAssistantSubscribeFlag>(enums::VoiceAssistantSubscribeFlag value) {
+  switch (value) {
+    case enums::VOICE_ASSISTANT_SUBSCRIBE_NONE:
+      return "VOICE_ASSISTANT_SUBSCRIBE_NONE";
+    case enums::VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO:
+      return "VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
 template<> const char *proto_enum_to_string<enums::VoiceAssistantRequestFlag>(enums::VoiceAssistantRequestFlag value) {
   switch (value) {
     case enums::VOICE_ASSISTANT_REQUEST_NONE:
@@ -716,7 +729,11 @@ bool DeviceInfoResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
       return true;
     }
     case 14: {
-      this->voice_assistant_version = value.as_uint32();
+      this->legacy_voice_assistant_version = value.as_uint32();
+      return true;
+    }
+    case 17: {
+      this->voice_assistant_feature_flags = value.as_uint32();
       return true;
     }
     default:
@@ -784,7 +801,8 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(15, this->bluetooth_proxy_feature_flags);
   buffer.encode_string(12, this->manufacturer);
   buffer.encode_string(13, this->friendly_name);
-  buffer.encode_uint32(14, this->voice_assistant_version);
+  buffer.encode_uint32(14, this->legacy_voice_assistant_version);
+  buffer.encode_uint32(17, this->voice_assistant_feature_flags);
   buffer.encode_string(16, this->suggested_area);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -850,8 +868,13 @@ void DeviceInfoResponse::dump_to(std::string &out) const {
   out.append("'").append(this->friendly_name).append("'");
   out.append("\n");
 
-  out.append("  voice_assistant_version: ");
-  sprintf(buffer, "%" PRIu32, this->voice_assistant_version);
+  out.append("  legacy_voice_assistant_version: ");
+  sprintf(buffer, "%" PRIu32, this->legacy_voice_assistant_version);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  voice_assistant_feature_flags: ");
+  sprintf(buffer, "%" PRIu32, this->voice_assistant_feature_flags);
   out.append(buffer);
   out.append("\n");
 
@@ -6514,11 +6537,18 @@ bool SubscribeVoiceAssistantRequest::decode_varint(uint32_t field_id, ProtoVarIn
       this->subscribe = value.as_bool();
       return true;
     }
+    case 2: {
+      this->flags = value.as_uint32();
+      return true;
+    }
     default:
       return false;
   }
 }
-void SubscribeVoiceAssistantRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->subscribe); }
+void SubscribeVoiceAssistantRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_bool(1, this->subscribe);
+  buffer.encode_uint32(2, this->flags);
+}
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeVoiceAssistantRequest::dump_to(std::string &out) const {
   __attribute__((unused)) char buffer[64];
@@ -6526,6 +6556,11 @@ void SubscribeVoiceAssistantRequest::dump_to(std::string &out) const {
   out.append("  subscribe: ");
   out.append(YESNO(this->subscribe));
   out.append("\n");
+
+  out.append("  flags: ");
+  sprintf(buffer, "%" PRIu32, this->flags);
+  out.append(buffer);
+  out.append("\n");
   out.append("}");
 }
 #endif
@@ -6752,6 +6787,44 @@ void VoiceAssistantEventResponse::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool VoiceAssistantAudio::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->end = value.as_bool();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->data = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_string(1, this->data);
+  buffer.encode_bool(2, this->end);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void VoiceAssistantAudio::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("VoiceAssistantAudio {\n");
+  out.append("  data: ");
+  out.append("'").append(this->data).append("'");
+  out.append("\n");
+
+  out.append("  end: ");
+  out.append(YESNO(this->end));
+  out.append("\n");
+  out.append("}");
+}
+#endif
 bool ListEntitiesAlarmControlPanelResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {
     case 6: {
@@ -7403,6 +7476,225 @@ void DateCommandRequest::dump_to(std::string &out) const {
   out.append("}");
 }
 #endif
+bool ListEntitiesTimeResponse::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 ListEntitiesTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 1: {
+      this->object_id = value.as_string();
+      return true;
+    }
+    case 3: {
+      this->name = value.as_string();
+      return true;
+    }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
+    case 5: {
+      this->icon = value.as_string();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool ListEntitiesTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 2: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void ListEntitiesTimeResponse::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);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void ListEntitiesTimeResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("ListEntitiesTimeResponse {\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("}");
+}
+#endif
+bool TimeStateResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->missing_state = value.as_bool();
+      return true;
+    }
+    case 3: {
+      this->hour = value.as_uint32();
+      return true;
+    }
+    case 4: {
+      this->minute = value.as_uint32();
+      return true;
+    }
+    case 5: {
+      this->second = value.as_uint32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool TimeStateResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void TimeStateResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_bool(2, this->missing_state);
+  buffer.encode_uint32(3, this->hour);
+  buffer.encode_uint32(4, this->minute);
+  buffer.encode_uint32(5, this->second);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void TimeStateResponse::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("TimeStateResponse {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  missing_state: ");
+  out.append(YESNO(this->missing_state));
+  out.append("\n");
+
+  out.append("  hour: ");
+  sprintf(buffer, "%" PRIu32, this->hour);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  minute: ");
+  sprintf(buffer, "%" PRIu32, this->minute);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  second: ");
+  sprintf(buffer, "%" PRIu32, this->second);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+#endif
+bool TimeCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 2: {
+      this->hour = value.as_uint32();
+      return true;
+    }
+    case 3: {
+      this->minute = value.as_uint32();
+      return true;
+    }
+    case 4: {
+      this->second = value.as_uint32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+bool TimeCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
+  switch (field_id) {
+    case 1: {
+      this->key = value.as_fixed32();
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+void TimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_fixed32(1, this->key);
+  buffer.encode_uint32(2, this->hour);
+  buffer.encode_uint32(3, this->minute);
+  buffer.encode_uint32(4, this->second);
+}
+#ifdef HAS_PROTO_MESSAGE_DUMP
+void TimeCommandRequest::dump_to(std::string &out) const {
+  __attribute__((unused)) char buffer[64];
+  out.append("TimeCommandRequest {\n");
+  out.append("  key: ");
+  sprintf(buffer, "%" PRIu32, this->key);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  hour: ");
+  sprintf(buffer, "%" PRIu32, this->hour);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  minute: ");
+  sprintf(buffer, "%" PRIu32, this->minute);
+  out.append(buffer);
+  out.append("\n");
+
+  out.append("  second: ");
+  sprintf(buffer, "%" PRIu32, this->second);
+  out.append(buffer);
+  out.append("\n");
+  out.append("}");
+}
+#endif
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2.h

@@ -165,6 +165,10 @@ enum BluetoothDeviceRequestType : uint32_t {
   BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE = 5,
   BLUETOOTH_DEVICE_REQUEST_TYPE_CLEAR_CACHE = 6,
 };
+enum VoiceAssistantSubscribeFlag : uint32_t {
+  VOICE_ASSISTANT_SUBSCRIBE_NONE = 0,
+  VOICE_ASSISTANT_SUBSCRIBE_API_AUDIO = 1,
+};
 enum VoiceAssistantRequestFlag : uint32_t {
   VOICE_ASSISTANT_REQUEST_NONE = 0,
   VOICE_ASSISTANT_REQUEST_USE_VAD = 1,
@@ -327,7 +331,8 @@ class DeviceInfoResponse : public ProtoMessage {
   uint32_t bluetooth_proxy_feature_flags{0};
   std::string manufacturer{};
   std::string friendly_name{};
-  uint32_t voice_assistant_version{0};
+  uint32_t legacy_voice_assistant_version{0};
+  uint32_t voice_assistant_feature_flags{0};
   std::string suggested_area{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1674,6 +1679,7 @@ class BluetoothDeviceClearCacheResponse : public ProtoMessage {
 class SubscribeVoiceAssistantRequest : public ProtoMessage {
  public:
   bool subscribe{false};
+  uint32_t flags{0};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -1749,6 +1755,19 @@ class VoiceAssistantEventResponse : public ProtoMessage {
   bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class VoiceAssistantAudio : public ProtoMessage {
+ public:
+  std::string data{};
+  bool end{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 class ListEntitiesAlarmControlPanelResponse : public ProtoMessage {
  public:
   std::string object_id{};
@@ -1900,6 +1919,56 @@ class DateCommandRequest : public ProtoMessage {
   bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
   bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
 };
+class ListEntitiesTimeResponse : 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{};
+  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 TimeStateResponse : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  bool missing_state{false};
+  uint32_t hour{0};
+  uint32_t minute{0};
+  uint32_t second{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class TimeCommandRequest : public ProtoMessage {
+ public:
+  uint32_t key{0};
+  uint32_t hour{0};
+  uint32_t minute{0};
+  uint32_t second{0};
+  void encode(ProtoWriteBuffer buffer) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  void dump_to(std::string &out) const override;
+#endif
+
+ protected:
+  bool decode_32bit(uint32_t field_id, Proto32Bit value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
 
 }  // namespace api
 }  // namespace esphome

esphome/components/api/api_pb2_service.cpp

@@ -476,6 +476,14 @@ bool APIServerConnectionBase::send_voice_assistant_request(const VoiceAssistantR
 #endif
 #ifdef USE_VOICE_ASSISTANT
 #endif
+#ifdef USE_VOICE_ASSISTANT
+bool APIServerConnectionBase::send_voice_assistant_audio(const VoiceAssistantAudio &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_voice_assistant_audio: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<VoiceAssistantAudio>(msg, 106);
+}
+#endif
 #ifdef USE_ALARM_CONTROL_PANEL
 bool APIServerConnectionBase::send_list_entities_alarm_control_panel_response(
     const ListEntitiesAlarmControlPanelResponse &msg) {
@@ -531,6 +539,24 @@ bool APIServerConnectionBase::send_date_state_response(const DateStateResponse &
 #endif
 #ifdef USE_DATETIME_DATE
 #endif
+#ifdef USE_DATETIME_TIME
+bool APIServerConnectionBase::send_list_entities_time_response(const ListEntitiesTimeResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_list_entities_time_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<ListEntitiesTimeResponse>(msg, 103);
+}
+#endif
+#ifdef USE_DATETIME_TIME
+bool APIServerConnectionBase::send_time_state_response(const TimeStateResponse &msg) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  ESP_LOGVV(TAG, "send_time_state_response: %s", msg.dump().c_str());
+#endif
+  return this->send_message_<TimeStateResponse>(msg, 104);
+}
+#endif
+#ifdef USE_DATETIME_TIME
+#endif
 bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
@@ -971,6 +997,28 @@ bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ESP_LOGVV(TAG, "on_date_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_command_request(msg);
+#endif
+      break;
+    }
+    case 105: {
+#ifdef USE_DATETIME_TIME
+      TimeCommandRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_time_command_request: %s", msg.dump().c_str());
+#endif
+      this->on_time_command_request(msg);
+#endif
+      break;
+    }
+    case 106: {
+#ifdef USE_VOICE_ASSISTANT
+      VoiceAssistantAudio msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      ESP_LOGVV(TAG, "on_voice_assistant_audio: %s", msg.dump().c_str());
+#endif
+      this->on_voice_assistant_audio(msg);
 #endif
       break;
     }
@@ -1260,6 +1308,19 @@ void APIServerConnection::on_date_command_request(const DateCommandRequest &msg)
   this->date_command(msg);
 }
 #endif
+#ifdef USE_DATETIME_TIME
+void APIServerConnection::on_time_command_request(const TimeCommandRequest &msg) {
+  if (!this->is_connection_setup()) {
+    this->on_no_setup_connection();
+    return;
+  }
+  if (!this->is_authenticated()) {
+    this->on_unauthenticated_access();
+    return;
+  }
+  this->time_command(msg);
+}
+#endif
 #ifdef USE_BLUETOOTH_PROXY
 void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
     const SubscribeBluetoothLEAdvertisementsRequest &msg) {

esphome/components/api/api_pb2_service.h

@@ -240,6 +240,10 @@ class APIServerConnectionBase : public ProtoService {
 #ifdef USE_VOICE_ASSISTANT
   virtual void on_voice_assistant_event_response(const VoiceAssistantEventResponse &value){};
 #endif
+#ifdef USE_VOICE_ASSISTANT
+  bool send_voice_assistant_audio(const VoiceAssistantAudio &msg);
+  virtual void on_voice_assistant_audio(const VoiceAssistantAudio &value){};
+#endif
 #ifdef USE_ALARM_CONTROL_PANEL
   bool send_list_entities_alarm_control_panel_response(const ListEntitiesAlarmControlPanelResponse &msg);
 #endif
@@ -266,6 +270,15 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 #ifdef USE_DATETIME_DATE
   virtual void on_date_command_request(const DateCommandRequest &value){};
+#endif
+#ifdef USE_DATETIME_TIME
+  bool send_list_entities_time_response(const ListEntitiesTimeResponse &msg);
+#endif
+#ifdef USE_DATETIME_TIME
+  bool send_time_state_response(const TimeStateResponse &msg);
+#endif
+#ifdef USE_DATETIME_TIME
+  virtual void on_time_command_request(const TimeCommandRequest &value){};
 #endif
  protected:
   bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
@@ -324,6 +337,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_DATETIME_DATE
   virtual void date_command(const DateCommandRequest &msg) = 0;
 #endif
+#ifdef USE_DATETIME_TIME
+  virtual void time_command(const TimeCommandRequest &msg) = 0;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
 #endif
@@ -413,6 +429,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_DATETIME_DATE
   void on_date_command_request(const DateCommandRequest &msg) override;
 #endif
+#ifdef USE_DATETIME_TIME
+  void on_time_command_request(const TimeCommandRequest &msg) override;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
 #endif

esphome/components/api/api_server.cpp

@@ -264,6 +264,15 @@ void APIServer::on_date_update(datetime::DateEntity *obj) {
 }
 #endif
 
+#ifdef USE_DATETIME_TIME
+void APIServer::on_time_update(datetime::TimeEntity *obj) {
+  if (obj->is_internal())
+    return;
+  for (auto &c : this->clients_)
+    c->send_time_state(obj);
+}
+#endif
+
 #ifdef USE_TEXT
 void APIServer::on_text_update(text::Text *obj, const std::string &state) {
   if (obj->is_internal())

esphome/components/api/api_server.h

@@ -69,6 +69,9 @@ class APIServer : public Component, public Controller {
 #ifdef USE_DATETIME_DATE
   void on_date_update(datetime::DateEntity *obj) override;
 #endif
+#ifdef USE_DATETIME_TIME
+  void on_time_update(datetime::TimeEntity *obj) override;
+#endif
 #ifdef USE_TEXT
   void on_text_update(text::Text *obj, const std::string &state) override;
 #endif

esphome/components/api/list_entities.cpp

@@ -64,6 +64,10 @@ bool ListEntitiesIterator::on_number(number::Number *number) { return this->clie
 bool ListEntitiesIterator::on_date(datetime::DateEntity *date) { return this->client_->send_date_info(date); }
 #endif
 
+#ifdef USE_DATETIME_TIME
+bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) { return this->client_->send_time_info(time); }
+#endif
+
 #ifdef USE_TEXT
 bool ListEntitiesIterator::on_text(text::Text *text) { return this->client_->send_text_info(text); }
 #endif

esphome/components/api/list_entities.h

@@ -49,6 +49,9 @@ class ListEntitiesIterator : public ComponentIterator {
 #ifdef USE_DATETIME_DATE
   bool on_date(datetime::DateEntity *date) override;
 #endif
+#ifdef USE_DATETIME_TIME
+  bool on_time(datetime::TimeEntity *time) override;
+#endif
 #ifdef USE_TEXT
   bool on_text(text::Text *text) override;
 #endif

esphome/components/api/subscribe_state.cpp

@@ -45,6 +45,9 @@ bool InitialStateIterator::on_number(number::Number *number) {
 #ifdef USE_DATETIME_DATE
 bool InitialStateIterator::on_date(datetime::DateEntity *date) { return this->client_->send_date_state(date); }
 #endif
+#ifdef USE_DATETIME_TIME
+bool InitialStateIterator::on_time(datetime::TimeEntity *time) { return this->client_->send_time_state(time); }
+#endif
 #ifdef USE_TEXT
 bool InitialStateIterator::on_text(text::Text *text) { return this->client_->send_text_state(text, text->state); }
 #endif

esphome/components/api/subscribe_state.h

@@ -46,6 +46,9 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_DATETIME_DATE
   bool on_date(datetime::DateEntity *date) override;
 #endif
+#ifdef USE_DATETIME_TIME
+  bool on_time(datetime::TimeEntity *time) override;
+#endif
 #ifdef USE_TEXT
   bool on_text(text::Text *text) override;
 #endif

esphome/components/ble_presence/ble_presence_device.h

@@ -73,8 +73,7 @@ class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
         break;
       case MATCH_BY_IRK:
         if (resolve_irk_(device.address_uint64(), this->irk_)) {
-          this->publish_state(true);
-          this->found_ = true;
+          this->set_found_(true);
           return true;
         }
         break;

esphome/components/captive_portal/captive_index.h

@@ -6,100 +6,102 @@ namespace esphome {
 namespace captive_portal {
 
 const uint8_t INDEX_GZ[] PROGMEM = {
-    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xdd, 0x58, 0x5b, 0x8f, 0xdb, 0x36, 0x16, 0x7e, 0xef,
-    0xaf, 0xe0, 0x2a, 0x49, 0x2d, 0x37, 0x23, 0xea, 0x66, 0xf9, 0x2a, 0xa9, 0x48, 0xb2, 0x29, 0x5a, 0x20, 0x69, 0x03,
-    0xcc, 0xb4, 0xfb, 0x10, 0x04, 0x18, 0x5a, 0xa2, 0x2c, 0x66, 0x24, 0x4a, 0x15, 0xe9, 0x5b, 0x0c, 0xef, 0x6f, 0xdf,
-    0x43, 0x52, 0xf6, 0x38, 0xb3, 0x99, 0x05, 0x52, 0xec, 0x62, 0xd1, 0x4e, 0x26, 0x1c, 0x92, 0x3a, 0xd7, 0x4f, 0x3c,
-    0x17, 0x2a, 0xfe, 0x5b, 0xde, 0x64, 0x72, 0xdf, 0x52, 0x54, 0xca, 0xba, 0x4a, 0x63, 0x35, 0xa2, 0x8a, 0xf0, 0x55,
-    0x42, 0x39, 0xac, 0x28, 0xc9, 0xd3, 0xb8, 0xa6, 0x92, 0xa0, 0xac, 0x24, 0x9d, 0xa0, 0x32, 0xf9, 0xf5, 0xe6, 0x07,
-    0x67, 0x8a, 0xdc, 0x34, 0xae, 0x18, 0xbf, 0x43, 0x1d, 0xad, 0x12, 0x96, 0x35, 0x1c, 0x95, 0x1d, 0x2d, 0x92, 0x9c,
-    0x48, 0x32, 0x67, 0x35, 0x59, 0x51, 0x45, 0xa0, 0xd9, 0x38, 0xa9, 0x69, 0xb2, 0x61, 0x74, 0xdb, 0x36, 0x9d, 0x44,
-    0x40, 0x29, 0x29, 0x97, 0x89, 0xb5, 0x65, 0xb9, 0x2c, 0x93, 0x9c, 0x6e, 0x58, 0x46, 0x1d, 0xbd, 0xb8, 0x62, 0x9c,
-    0x49, 0x46, 0x2a, 0x47, 0x64, 0xa4, 0xa2, 0x89, 0x7f, 0xb5, 0x16, 0xb4, 0xd3, 0x0b, 0xb2, 0x84, 0x35, 0x6f, 0x2c,
-    0x10, 0x29, 0xb2, 0x8e, 0xb5, 0x12, 0x29, 0x7b, 0x93, 0xba, 0xc9, 0xd7, 0x15, 0x4d, 0x5d, 0x97, 0x08, 0xb0, 0x4b,
-    0xb8, 0x8c, 0xe7, 0x74, 0x87, 0xa7, 0xb3, 0x68, 0x32, 0x9e, 0xe6, 0x13, 0xfc, 0x51, 0x7c, 0x03, 0x9e, 0xad, 0x6b,
-    0x50, 0x87, 0xab, 0x26, 0x23, 0x92, 0x35, 0x1c, 0x0b, 0x4a, 0xba, 0xac, 0x4c, 0x92, 0xc4, 0xfa, 0x5e, 0x90, 0x0d,
-    0xb5, 0xbe, 0xfd, 0xd6, 0x3e, 0x13, 0xad, 0xa8, 0x7c, 0x5d, 0x51, 0x35, 0x15, 0x2f, 0xf7, 0x37, 0x64, 0xf5, 0x33,
-    0x58, 0x6e, 0x5b, 0x44, 0xb0, 0x9c, 0x5a, 0xc3, 0xf7, 0xde, 0x07, 0x2c, 0xe4, 0xbe, 0xa2, 0x38, 0x67, 0xa2, 0xad,
-    0xc8, 0x3e, 0xb1, 0x96, 0x20, 0xf5, 0xce, 0x1a, 0x2e, 0x8a, 0x35, 0xcf, 0x94, 0x70, 0x24, 0x6c, 0x3a, 0x3c, 0x54,
-    0x14, 0xcc, 0x4b, 0xde, 0x12, 0x59, 0xe2, 0x9a, 0xec, 0x6c, 0x33, 0x61, 0xdc, 0x0e, 0xbe, 0xb3, 0xe9, 0x73, 0xdf,
-    0xf3, 0x86, 0x57, 0x7a, 0xf0, 0x86, 0x2e, 0xfc, 0x5d, 0x74, 0x54, 0xae, 0x3b, 0x8e, 0x88, 0x7d, 0x1b, 0xb7, 0x40,
-    0x89, 0xf2, 0xc4, 0xaa, 0xfd, 0x00, 0x7b, 0xde, 0x14, 0xf9, 0x33, 0x1c, 0x44, 0x8e, 0xef, 0xe3, 0xd0, 0xf1, 0xa3,
-    0x6c, 0xe2, 0x44, 0xc8, 0x1f, 0xc1, 0x10, 0x04, 0x38, 0x42, 0xde, 0x27, 0x0b, 0x15, 0xac, 0xaa, 0x12, 0x8b, 0x37,
-    0x9c, 0x5a, 0x48, 0xc8, 0xae, 0xb9, 0xa3, 0x89, 0x95, 0xad, 0xbb, 0x0e, 0xec, 0x7f, 0xd5, 0x54, 0x4d, 0x07, 0x70,
-    0x7d, 0x83, 0x3e, 0xfb, 0xf9, 0x6a, 0x15, 0xb2, 0x23, 0x5c, 0x14, 0x4d, 0x57, 0x27, 0x96, 0x7e, 0x29, 0xf6, 0xd3,
-    0x83, 0x3c, 0x22, 0x35, 0x0c, 0x2f, 0x1e, 0x3a, 0x4d, 0xc7, 0x56, 0x8c, 0x27, 0x96, 0x1f, 0x20, 0x7f, 0x0a, 0x6a,
-    0x6f, 0x87, 0xc7, 0x33, 0x26, 0x44, 0x61, 0xd2, 0x7b, 0xd9, 0xd8, 0xef, 0x6f, 0x63, 0xb1, 0x59, 0xa1, 0x5d, 0x5d,
-    0x71, 0x91, 0x58, 0xa5, 0x94, 0xed, 0xdc, 0x75, 0xb7, 0xdb, 0x2d, 0xde, 0x86, 0xb8, 0xe9, 0x56, 0x6e, 0xe0, 0x79,
-    0x9e, 0x0b, 0x14, 0x16, 0x32, 0xe7, 0xc3, 0x0a, 0x46, 0x16, 0x2a, 0x29, 0x5b, 0x95, 0x52, 0xcf, 0xd3, 0xa7, 0x07,
-    0x7a, 0x8c, 0x15, 0x45, 0x7a, 0xfb, 0xe1, 0x42, 0x4b, 0x77, 0xa1, 0x85, 0x7e, 0x7f, 0x81, 0xe6, 0xe0, 0xad, 0x32,
-    0x6a, 0x42, 0x02, 0x14, 0x20, 0x4f, 0xff, 0x0b, 0x1c, 0x35, 0xef, 0x57, 0xce, 0x83, 0x15, 0xba, 0x58, 0xc1, 0x5f,
-    0xc0, 0x2f, 0xa8, 0xc7, 0xce, 0xec, 0xcc, 0xee, 0xab, 0xc7, 0x1b, 0xdf, 0xbb, 0xdf, 0x50, 0x3c, 0x3f, 0x8e, 0x2f,
-    0xd7, 0x4e, 0xf0, 0x9b, 0x22, 0x50, 0xd8, 0x9f, 0x99, 0x9c, 0xa0, 0xf4, 0x7f, 0x1b, 0x93, 0x08, 0x45, 0xfd, 0x4e,
-    0xe4, 0xa8, 0xf9, 0x79, 0xa5, 0x34, 0xa1, 0x68, 0x03, 0x54, 0xb5, 0x33, 0x76, 0x22, 0x12, 0xa2, 0xb0, 0x37, 0x09,
-    0x66, 0xb0, 0x3d, 0x06, 0xe6, 0x8b, 0x3d, 0x27, 0xfc, 0x34, 0x50, 0x30, 0xcf, 0x2d, 0xeb, 0x1e, 0x83, 0xe6, 0x12,
-    0x03, 0xfc, 0xb1, 0x81, 0x33, 0x67, 0x59, 0x80, 0x11, 0x95, 0x59, 0x69, 0x5b, 0x2e, 0x44, 0x5e, 0xc1, 0x56, 0x10,
-    0x15, 0x0d, 0xb7, 0x86, 0x58, 0x96, 0x94, 0xdb, 0x27, 0x56, 0xc5, 0x48, 0xf5, 0x13, 0xfb, 0xe1, 0x13, 0x39, 0x3c,
-    0x9c, 0xe3, 0x43, 0x32, 0x09, 0x71, 0x28, 0xb1, 0x8a, 0xe8, 0xab, 0xf3, 0xee, 0xb2, 0xc9, 0xf7, 0x8f, 0x84, 0x4e,
-    0xe9, 0x9b, 0xb8, 0x61, 0x9c, 0xd3, 0xee, 0x86, 0xee, 0xe0, 0x1d, 0xfe, 0x83, 0xfd, 0xc0, 0xd0, 0xcf, 0x54, 0x6e,
-    0x9b, 0xee, 0x4e, 0xcc, 0x91, 0xf5, 0xdc, 0x88, 0x5b, 0xa8, 0xa8, 0x61, 0x20, 0x9b, 0xb4, 0x02, 0x8b, 0x0a, 0x72,
-    0x82, 0xed, 0x0f, 0x21, 0x7e, 0xda, 0x7b, 0x4b, 0xf8, 0xc9, 0xb9, 0xdb, 0x38, 0x67, 0x1b, 0x94, 0x55, 0x10, 0xf5,
-    0x70, 0xfc, 0x8d, 0x28, 0x0b, 0xf5, 0x47, 0xbd, 0xe1, 0x19, 0x70, 0xdf, 0x25, 0xd6, 0x17, 0xa2, 0xfa, 0xe5, 0xfe,
-    0xa7, 0xdc, 0x1e, 0x08, 0x88, 0xe7, 0xc1, 0x10, 0x6f, 0x48, 0xb5, 0xa6, 0x28, 0x41, 0xb2, 0x64, 0xe2, 0xde, 0xc0,
-    0xc5, 0xa3, 0x6c, 0xad, 0xb8, 0x03, 0xae, 0x02, 0x1e, 0x0b, 0x7b, 0x68, 0x9d, 0x22, 0x2b, 0x26, 0x26, 0xef, 0x59,
-    0x4f, 0xac, 0x07, 0x16, 0x39, 0x15, 0x2d, 0xa4, 0x75, 0x1f, 0x81, 0x4f, 0x0f, 0xc2, 0xe6, 0xb8, 0x03, 0xed, 0xc3,
-    0xe3, 0x79, 0x33, 0x16, 0x2d, 0xe1, 0x0f, 0x19, 0x95, 0x81, 0xea, 0xa0, 0x43, 0xb2, 0x82, 0x99, 0x3a, 0xed, 0x40,
-    0x74, 0x56, 0xe8, 0x92, 0xd3, 0xf4, 0xe9, 0xa1, 0x03, 0x89, 0x2a, 0x07, 0x9d, 0x25, 0xc6, 0x2e, 0x40, 0x93, 0xde,
-    0x1e, 0x87, 0xf7, 0x7e, 0xfc, 0xbe, 0xa6, 0xdd, 0xfe, 0x9a, 0x56, 0x34, 0x93, 0x4d, 0x67, 0x5b, 0x4f, 0x40, 0x0b,
-    0xbc, 0x7e, 0xed, 0xf0, 0x8f, 0x37, 0x6f, 0xdf, 0x24, 0x8d, 0xcd, 0x86, 0x57, 0x8f, 0x51, 0xab, 0x0c, 0xff, 0x1e,
-    0x32, 0xfc, 0x3f, 0x93, 0x81, 0xca, 0xf1, 0x83, 0x0f, 0xc0, 0xaa, 0xfd, 0xbd, 0xbd, 0x4f, 0xf4, 0x2a, 0x18, 0x9f,
-    0x43, 0x40, 0x5f, 0x29, 0x0f, 0x9d, 0x71, 0x34, 0x3c, 0x82, 0x7e, 0xb0, 0x00, 0xec, 0xd6, 0xb9, 0x1a, 0x72, 0xb6,
-    0x4a, 0x9b, 0xe9, 0x77, 0x87, 0x65, 0xb3, 0x73, 0x04, 0xfb, 0xc4, 0xf8, 0x6a, 0xce, 0x78, 0x49, 0x3b, 0x26, 0x8f,
-    0x60, 0x2e, 0xa4, 0xfd, 0x76, 0x2d, 0x0f, 0x2d, 0xc9, 0x73, 0xf5, 0x24, 0x6a, 0x77, 0x8b, 0x02, 0x8a, 0x84, 0xa2,
-    0xa4, 0x73, 0x9f, 0xd6, 0x47, 0xf3, 0x5c, 0xe7, 0x83, 0xf9, 0x2c, 0x7a, 0x76, 0x54, 0x07, 0xee, 0x20, 0xe1, 0x65,
-    0x39, 0xa4, 0x62, 0x2b, 0x3e, 0xcf, 0xc0, 0x70, 0xda, 0x19, 0xa6, 0x82, 0xd4, 0xac, 0xda, 0xcf, 0x05, 0x64, 0x26,
-    0x07, 0xaa, 0x07, 0x2b, 0x8e, 0xcb, 0xb5, 0x94, 0x0d, 0x07, 0xdd, 0x5d, 0x4e, 0xbb, 0xb9, 0xb7, 0x30, 0x13, 0xa7,
-    0x23, 0x39, 0x5b, 0x8b, 0x39, 0x0e, 0x3b, 0x5a, 0x2f, 0x96, 0x24, 0xbb, 0x5b, 0x75, 0xcd, 0x9a, 0xe7, 0x4e, 0xa6,
-    0x32, 0xe7, 0xfc, 0x89, 0x5f, 0x90, 0x90, 0x66, 0x8b, 0x7e, 0x55, 0x14, 0xc5, 0x02, 0xa0, 0xa0, 0x8e, 0xc9, 0x44,
-    0xf3, 0x00, 0x8f, 0x14, 0xdb, 0x85, 0x99, 0x38, 0x50, 0x1b, 0xc6, 0x46, 0x48, 0xeb, 0xcf, 0x16, 0x27, 0x77, 0xbc,
-    0x05, 0xa4, 0x64, 0x01, 0x42, 0x5a, 0x88, 0x47, 0x30, 0xf3, 0x58, 0x13, 0xc6, 0x2f, 0xad, 0x57, 0xc7, 0x64, 0xd1,
-    0x97, 0x14, 0x80, 0x45, 0xab, 0xd1, 0x85, 0x65, 0x01, 0x45, 0xc3, 0x14, 0xc6, 0x79, 0x30, 0xf6, 0xda, 0xdd, 0x11,
-    0xf7, 0x07, 0xe4, 0x70, 0xa2, 0x2e, 0x2a, 0xba, 0x5b, 0x7c, 0x5c, 0x0b, 0xc9, 0x8a, 0xbd, 0xd3, 0x17, 0xd6, 0x39,
-    0x1c, 0x16, 0x28, 0xa8, 0x4b, 0x20, 0xa5, 0x94, 0x2f, 0xb4, 0x0e, 0x87, 0x49, 0x5a, 0x8b, 0x1e, 0xa7, 0xb3, 0x18,
-    0x7d, 0x40, 0x3f, 0x97, 0xf5, 0x9f, 0xa8, 0xd5, 0x59, 0x3c, 0xd4, 0xa4, 0x83, 0x44, 0xef, 0x2c, 0x1b, 0xc0, 0xb4,
-    0x9e, 0x3b, 0x13, 0x78, 0x57, 0xfd, 0x96, 0x12, 0x06, 0x9e, 0x83, 0x99, 0xba, 0x5e, 0x9e, 0xf0, 0xf6, 0xdb, 0x1d,
-    0x12, 0x4d, 0xc5, 0xf2, 0x9e, 0x4e, 0x93, 0x20, 0xef, 0x0c, 0x8f, 0x0f, 0xaf, 0x1b, 0xa9, 0xbd, 0x13, 0xd4, 0xa3,
-    0x62, 0x4a, 0x7c, 0xef, 0x0b, 0x6f, 0x24, 0x2f, 0x8a, 0x60, 0x59, 0x9c, 0x91, 0x52, 0x65, 0xef, 0xc8, 0xfa, 0x53,
-    0x11, 0x8c, 0x40, 0xc0, 0xe9, 0xdd, 0xc0, 0xfc, 0xc8, 0x74, 0x58, 0x1c, 0x2e, 0xa4, 0xe8, 0xa3, 0x3a, 0x5f, 0x77,
-    0x95, 0x6d, 0x7d, 0xe1, 0xe8, 0x3e, 0x0b, 0x5f, 0xdd, 0x97, 0xa5, 0xc1, 0xe3, 0x65, 0x69, 0x80, 0x54, 0x23, 0xf3,
-    0xb2, 0xd9, 0x25, 0x03, 0x5d, 0x20, 0x46, 0xf0, 0x3b, 0x78, 0x16, 0xbe, 0x06, 0xfe, 0xff, 0x4a, 0xbd, 0xf9, 0xc3,
-    0xc5, 0xe6, 0x2b, 0x2a, 0xcd, 0x57, 0x56, 0x19, 0xe3, 0x9d, 0x72, 0x1e, 0x66, 0x50, 0x4e, 0x18, 0x16, 0x6c, 0xe5,
-    0xff, 0x2f, 0xa0, 0xfd, 0x77, 0x1c, 0xc3, 0x17, 0xfe, 0x14, 0xcf, 0x90, 0x1e, 0x0c, 0x44, 0x38, 0x9c, 0xa2, 0xc9,
-    0xab, 0x11, 0x1e, 0xf9, 0x48, 0xb5, 0x30, 0x63, 0x34, 0x81, 0x7e, 0x0f, 0xf9, 0x63, 0x1c, 0x4e, 0x60, 0x03, 0x05,
-    0x3e, 0x8e, 0xde, 0x04, 0x21, 0x1e, 0x47, 0x40, 0x15, 0x78, 0x38, 0x0c, 0x90, 0xa1, 0x1d, 0xe3, 0x00, 0xc4, 0x29,
-    0x92, 0xb0, 0x06, 0xa0, 0xb3, 0x10, 0x7b, 0x13, 0x10, 0x37, 0xc6, 0xde, 0x0c, 0x4f, 0xc7, 0x68, 0x8a, 0x27, 0x00,
-    0x1d, 0x1e, 0x45, 0x95, 0x13, 0x61, 0x1f, 0xb6, 0xc3, 0x31, 0x99, 0xe2, 0x51, 0x88, 0xf4, 0x60, 0xe0, 0x98, 0x80,
-    0x08, 0x07, 0x7b, 0xfe, 0x9b, 0x10, 0x07, 0x13, 0xd0, 0x3b, 0x1a, 0xbd, 0x00, 0xb1, 0xb3, 0x11, 0x32, 0xa3, 0x81,
-    0x17, 0x14, 0x44, 0x8f, 0x81, 0x16, 0xfc, 0x75, 0x41, 0x03, 0x48, 0x7c, 0x14, 0xe2, 0x19, 0xc4, 0xae, 0xaf, 0xf8,
-    0xcd, 0x68, 0x70, 0xf3, 0x7d, 0xe4, 0xfd, 0x61, 0xcc, 0xc2, 0xbf, 0x2e, 0x66, 0xbe, 0x42, 0x00, 0xa6, 0xa0, 0x1b,
-    0xe4, 0x20, 0x3d, 0x18, 0xdd, 0xc0, 0x3c, 0x7d, 0x35, 0x43, 0x53, 0xe0, 0x1a, 0x4f, 0xd1, 0x0c, 0x45, 0x0a, 0x5d,
-    0x60, 0x1f, 0x19, 0x26, 0x07, 0x98, 0xbe, 0x12, 0xc6, 0xd1, 0x9f, 0x18, 0xc6, 0xc7, 0x7c, 0xfa, 0x13, 0xbb, 0xf4,
-    0xff, 0x48, 0x41, 0xd0, 0x8e, 0xe9, 0x36, 0x2c, 0x76, 0xcd, 0x95, 0x5e, 0x75, 0x51, 0x70, 0x43, 0x87, 0x6e, 0x04,
-    0x2e, 0xf9, 0x3e, 0x62, 0x79, 0x52, 0xfa, 0xe9, 0x67, 0xdd, 0x39, 0x50, 0xfa, 0x69, 0xac, 0xcb, 0x79, 0x7a, 0x53,
-    0x52, 0xf4, 0xfa, 0xfa, 0x1d, 0xdc, 0xca, 0xaa, 0x0a, 0xf1, 0x66, 0x0b, 0x97, 0xbf, 0x3d, 0x92, 0x8d, 0xba, 0xce,
-    0x73, 0xe8, 0x15, 0xd5, 0x14, 0xee, 0x0d, 0xa8, 0x6f, 0x16, 0x30, 0xc6, 0xf1, 0xb2, 0x4b, 0xdf, 0x55, 0x94, 0x08,
-    0x8a, 0x56, 0x6c, 0x43, 0x11, 0x93, 0xd0, 0x07, 0xd4, 0x14, 0x49, 0xa6, 0x86, 0x33, 0xa3, 0xa6, 0x83, 0x9e, 0x56,
-    0x2b, 0x31, 0xdd, 0x30, 0x58, 0x02, 0x62, 0xd2, 0xbe, 0xed, 0x8d, 0xcb, 0xd0, 0x58, 0x75, 0x4d, 0xa5, 0x84, 0x8e,
-    0x41, 0x59, 0x15, 0xa6, 0xb1, 0xba, 0x76, 0x22, 0xa2, 0x2f, 0x06, 0x89, 0xbb, 0x65, 0x05, 0x53, 0x97, 0xf9, 0x34,
-    0xd6, 0xad, 0xa2, 0x92, 0xa0, 0xba, 0x15, 0xf3, 0xe5, 0x41, 0xcf, 0x2a, 0xca, 0x57, 0x70, 0x9b, 0x84, 0x77, 0x01,
-    0xcd, 0x43, 0x46, 0xcb, 0xa6, 0x82, 0xe6, 0x24, 0xb9, 0xbe, 0xfe, 0xe9, 0xef, 0xea, 0x33, 0x85, 0x32, 0xe1, 0xcc,
-    0x09, 0x7d, 0xbe, 0x61, 0x54, 0x93, 0x9e, 0x6f, 0x3c, 0x32, 0x1f, 0x1c, 0x5a, 0xe8, 0xd3, 0xc1, 0xbf, 0xfc, 0x33,
-    0x29, 0xef, 0x4e, 0x9b, 0xbd, 0x24, 0xfd, 0x5f, 0x37, 0x9d, 0x86, 0x49, 0xac, 0x97, 0x35, 0x93, 0xe9, 0x35, 0x18,
-    0x18, 0xbb, 0xe6, 0x01, 0x38, 0xa7, 0x1c, 0x30, 0xb4, 0x65, 0xcf, 0x03, 0x60, 0xff, 0x72, 0xf3, 0x02, 0xfd, 0xda,
-    0xc2, 0x09, 0xa6, 0x06, 0x7b, 0xed, 0x65, 0x4d, 0x65, 0xd9, 0xe4, 0xc9, 0xbb, 0x5f, 0xae, 0x6f, 0xce, 0x1e, 0xaf,
-    0x35, 0x11, 0xa2, 0x3c, 0x33, 0x1f, 0x42, 0xd6, 0x95, 0x64, 0x2d, 0xe9, 0xa4, 0x16, 0xeb, 0xa8, 0x10, 0x38, 0x79,
-    0xa4, 0x9f, 0x17, 0xac, 0xa2, 0xc6, 0xa9, 0x9e, 0xd1, 0x4d, 0xd1, 0x97, 0x6c, 0x3c, 0xe9, 0x7e, 0x60, 0xa5, 0x6b,
-    0x4e, 0x89, 0x6b, 0x8e, 0x8c, 0xab, 0x3f, 0x13, 0xfd, 0x0b, 0x65, 0x37, 0xa3, 0x8e, 0x36, 0x12, 0x00, 0x00};
+    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xdd, 0x58, 0x69, 0x6f, 0xdc, 0x36, 0x1a, 0xfe, 0xde,
+    0x5f, 0xc1, 0x2a, 0x49, 0x47, 0xd3, 0x58, 0xd4, 0x35, 0x9a, 0x53, 0x9a, 0xc2, 0xf1, 0xa6, 0x68, 0x81, 0xa4, 0x0d,
+    0x60, 0xb7, 0xfd, 0x10, 0x04, 0x30, 0x47, 0xa2, 0x46, 0x8c, 0x25, 0x4a, 0x2b, 0x72, 0xae, 0x0c, 0x66, 0x7f, 0xfb,
+    0xbe, 0x24, 0x35, 0xe3, 0xb1, 0x37, 0x5e, 0x6c, 0x8a, 0x2d, 0x8a, 0xd6, 0x71, 0x68, 0x1e, 0xef, 0xf9, 0x88, 0xef,
+    0x21, 0xc5, 0x5f, 0x67, 0x75, 0x2a, 0x77, 0x0d, 0x45, 0x85, 0xac, 0xca, 0x79, 0xac, 0x46, 0x54, 0x12, 0xbe, 0x4c,
+    0x28, 0x87, 0x15, 0x25, 0xd9, 0x3c, 0xae, 0xa8, 0x24, 0x28, 0x2d, 0x48, 0x2b, 0xa8, 0x4c, 0x7e, 0xb9, 0xf9, 0xde,
+    0x19, 0x23, 0x77, 0x1e, 0x97, 0x8c, 0xdf, 0xa1, 0x96, 0x96, 0x09, 0x4b, 0x6b, 0x8e, 0x8a, 0x96, 0xe6, 0x49, 0x46,
+    0x24, 0x99, 0xb2, 0x8a, 0x2c, 0xa9, 0x22, 0xd0, 0x6c, 0x9c, 0x54, 0x34, 0x59, 0x33, 0xba, 0x69, 0xea, 0x56, 0x22,
+    0xa0, 0x94, 0x94, 0xcb, 0xc4, 0xda, 0xb0, 0x4c, 0x16, 0x49, 0x46, 0xd7, 0x2c, 0xa5, 0x8e, 0x5e, 0x5c, 0x30, 0xce,
+    0x24, 0x23, 0xa5, 0x23, 0x52, 0x52, 0xd2, 0xc4, 0xbf, 0x58, 0x09, 0xda, 0xea, 0x05, 0x59, 0xc0, 0x9a, 0xd7, 0x16,
+    0x88, 0x14, 0x69, 0xcb, 0x1a, 0x89, 0x94, 0xbd, 0x49, 0x55, 0x67, 0xab, 0x92, 0xce, 0x5d, 0x97, 0x08, 0xb0, 0x4b,
+    0xb8, 0x8c, 0x67, 0x74, 0x8b, 0x87, 0x61, 0x98, 0x06, 0x64, 0x94, 0xe3, 0x8f, 0xe2, 0x2b, 0xf0, 0x6c, 0x55, 0x81,
+    0x3a, 0x5c, 0xd6, 0x29, 0x91, 0xac, 0xe6, 0x58, 0x50, 0xd2, 0xa6, 0x45, 0x92, 0x24, 0xd6, 0x77, 0x82, 0xac, 0xa9,
+    0xf5, 0xcd, 0x37, 0xf6, 0x89, 0x68, 0x49, 0xe5, 0xeb, 0x92, 0xaa, 0xa9, 0x78, 0xb5, 0xbb, 0x21, 0xcb, 0x9f, 0xc0,
+    0x72, 0xdb, 0x22, 0x82, 0x65, 0xd4, 0xea, 0xbf, 0xf7, 0x3e, 0x60, 0x21, 0x77, 0x25, 0xc5, 0x19, 0x13, 0x4d, 0x49,
+    0x76, 0x89, 0xb5, 0x00, 0xa9, 0x77, 0x56, 0x7f, 0x96, 0xaf, 0x78, 0xaa, 0x84, 0x23, 0x61, 0xd3, 0xfe, 0xbe, 0xa4,
+    0x60, 0x5e, 0xf2, 0x96, 0xc8, 0x02, 0x57, 0x64, 0x6b, 0x9b, 0x09, 0xe3, 0x76, 0xf0, 0xad, 0x4d, 0x5f, 0xfa, 0x9e,
+    0xd7, 0xbf, 0xd0, 0x83, 0xd7, 0x77, 0xe1, 0xef, 0xac, 0xa5, 0x72, 0xd5, 0x72, 0x44, 0xec, 0xdb, 0xb8, 0x01, 0x4a,
+    0x94, 0x25, 0x56, 0xe5, 0x07, 0xd8, 0xf3, 0xc6, 0xc8, 0x9f, 0xe0, 0x20, 0x72, 0x7c, 0x1f, 0x87, 0x8e, 0x1f, 0xa5,
+    0x23, 0x27, 0x42, 0xfe, 0x00, 0x86, 0x20, 0xc0, 0x11, 0xf2, 0x3e, 0x59, 0x28, 0x67, 0x65, 0x99, 0x58, 0xbc, 0xe6,
+    0xd4, 0x42, 0x42, 0xb6, 0xf5, 0x1d, 0x4d, 0xac, 0x74, 0xd5, 0xb6, 0x60, 0xff, 0x55, 0x5d, 0xd6, 0x2d, 0xc0, 0xf5,
+    0x15, 0x7a, 0xf0, 0xf3, 0xc5, 0x2a, 0x64, 0x4b, 0xb8, 0xc8, 0xeb, 0xb6, 0x4a, 0x2c, 0xfd, 0x50, 0xec, 0xe7, 0x7b,
+    0x79, 0x40, 0x6a, 0xe8, 0x9f, 0x1d, 0x3a, 0x75, 0xcb, 0x96, 0x8c, 0x27, 0x96, 0x1f, 0x20, 0x7f, 0x0c, 0x6a, 0x6f,
+    0xfb, 0x87, 0x13, 0x26, 0x44, 0x61, 0xd2, 0x79, 0x59, 0xdb, 0xef, 0x6f, 0x63, 0xb1, 0x5e, 0xa2, 0x6d, 0x55, 0x72,
+    0x91, 0x58, 0x85, 0x94, 0xcd, 0xd4, 0x75, 0x37, 0x9b, 0x0d, 0xde, 0x84, 0xb8, 0x6e, 0x97, 0x6e, 0xe0, 0x79, 0x9e,
+    0x0b, 0x14, 0x16, 0x32, 0xf7, 0xc3, 0x0a, 0x06, 0x16, 0x2a, 0x28, 0x5b, 0x16, 0x52, 0xcf, 0xe7, 0xcf, 0xf7, 0xf4,
+    0x10, 0x2b, 0x8a, 0xf9, 0xed, 0x87, 0x33, 0x2d, 0xec, 0x4c, 0x0b, 0xfd, 0xee, 0x0c, 0xcd, 0xde, 0x5b, 0x65, 0xd4,
+    0x88, 0x04, 0x28, 0x40, 0x9e, 0xfe, 0x17, 0x38, 0x6a, 0xde, 0xad, 0x9c, 0x47, 0x2b, 0x74, 0xb6, 0x82, 0xbf, 0x80,
+    0x5f, 0x50, 0x0d, 0x9d, 0xc9, 0x89, 0xdd, 0x57, 0xc7, 0x6b, 0xdf, 0xbb, 0xdf, 0x50, 0x3c, 0x3f, 0x0c, 0xcf, 0xd7,
+    0x4e, 0xf0, 0xab, 0x22, 0x50, 0xd8, 0x9f, 0x98, 0x9c, 0xa0, 0xf0, 0x7f, 0x1d, 0x92, 0x08, 0x45, 0xdd, 0x4e, 0xe4,
+    0xa8, 0xf9, 0x69, 0xa5, 0x34, 0xa1, 0x68, 0x0d, 0x54, 0x95, 0x33, 0x74, 0x22, 0x12, 0xa2, 0xb0, 0x33, 0x09, 0x66,
+    0xb0, 0x3d, 0x04, 0xe6, 0xb3, 0x3d, 0x27, 0xfc, 0xd4, 0x53, 0x30, 0x4f, 0x2d, 0xeb, 0x1e, 0x83, 0xfa, 0x1c, 0x03,
+    0xfc, 0xb1, 0x86, 0x3b, 0x67, 0x59, 0x80, 0x11, 0x95, 0x69, 0x61, 0x5b, 0x2e, 0x44, 0x5e, 0xce, 0x96, 0x10, 0x15,
+    0x35, 0xb7, 0xfa, 0x58, 0x16, 0x94, 0xdb, 0x47, 0x56, 0xc5, 0x48, 0xf5, 0x89, 0xfd, 0xf8, 0x44, 0xf6, 0xf7, 0xa7,
+    0xf8, 0x90, 0x4c, 0x42, 0x1c, 0x4a, 0xac, 0x22, 0xfa, 0xe2, 0xb4, 0xbb, 0xa8, 0xb3, 0xdd, 0x13, 0xa1, 0x53, 0xf8,
+    0x26, 0x6e, 0x18, 0xe7, 0xb4, 0xbd, 0xa1, 0x5b, 0x78, 0x86, 0x6f, 0x2f, 0xaf, 0xd0, 0x65, 0x96, 0xb5, 0x54, 0x88,
+    0x29, 0xb2, 0x5e, 0x4a, 0x88, 0x91, 0xf4, 0x7f, 0x97, 0xe5, 0x3f, 0x90, 0xf5, 0x1b, 0xfb, 0x9e, 0xa1, 0x9f, 0xa8,
+    0xdc, 0xd4, 0xed, 0x5d, 0x27, 0x4d, 0x99, 0x36, 0x53, 0x11, 0xd8, 0x82, 0x9d, 0xa4, 0x11, 0x58, 0x94, 0x90, 0x5f,
+    0x6c, 0xbf, 0x0f, 0x7a, 0x9a, 0x7b, 0xaf, 0xf8, 0x11, 0xa8, 0xdb, 0x38, 0x63, 0x6b, 0x94, 0x96, 0x90, 0x41, 0x20,
+    0x94, 0x8c, 0x28, 0x0b, 0x75, 0x61, 0x53, 0xf3, 0x14, 0xb8, 0xef, 0x12, 0xeb, 0x33, 0x19, 0xe2, 0xd5, 0xee, 0xc7,
+    0xcc, 0xee, 0x09, 0xc8, 0x0d, 0xbd, 0x3e, 0x5e, 0x93, 0x72, 0x45, 0x51, 0x82, 0x64, 0xc1, 0xc4, 0xbd, 0x81, 0xb3,
+    0x27, 0xd9, 0x1a, 0x71, 0x07, 0x5c, 0x39, 0x1c, 0x0b, 0xbb, 0x6f, 0x1d, 0xa3, 0x34, 0x26, 0x26, 0x87, 0x5a, 0xcf,
+    0xac, 0x47, 0x16, 0x39, 0x25, 0xcd, 0xa5, 0x75, 0x1f, 0xcd, 0xcf, 0xf7, 0xc2, 0xe6, 0xb8, 0x05, 0xed, 0xfd, 0xc3,
+    0x69, 0x33, 0x16, 0x0d, 0xe1, 0x8f, 0x19, 0x95, 0x81, 0x2a, 0x68, 0x20, 0xf1, 0xc1, 0x4c, 0x45, 0x0e, 0x10, 0x9d,
+    0x14, 0xba, 0xe4, 0x38, 0x7d, 0xbe, 0x67, 0x20, 0x51, 0xe5, 0xb3, 0x93, 0xc4, 0xd8, 0x05, 0x68, 0xe6, 0xb7, 0x87,
+    0xfe, 0xbd, 0x1f, 0xff, 0x5c, 0xd1, 0x76, 0x77, 0x4d, 0x4b, 0x9a, 0xca, 0xba, 0xb5, 0xad, 0x67, 0xa0, 0x05, 0xae,
+    0x92, 0x76, 0xf8, 0x87, 0x9b, 0xb7, 0x6f, 0x92, 0xda, 0x6e, 0xfb, 0x17, 0x4f, 0x51, 0xab, 0x6a, 0xf1, 0x1e, 0xaa,
+    0xc5, 0xbf, 0x92, 0x9e, 0xaa, 0x17, 0xbd, 0x0f, 0xc0, 0xaa, 0xfd, 0xbd, 0xbd, 0x2f, 0x1a, 0x2a, 0xb0, 0x5f, 0x42,
+    0x72, 0xb8, 0x50, 0x1e, 0x3a, 0xc3, 0xa8, 0x7f, 0x00, 0xfd, 0x60, 0x01, 0xd8, 0xad, 0xf3, 0x3e, 0xe4, 0x7f, 0x95,
+    0x82, 0xe7, 0xdf, 0xee, 0x17, 0xf5, 0xd6, 0x11, 0xec, 0x13, 0xe3, 0xcb, 0x29, 0xe3, 0x05, 0x6d, 0x99, 0x3c, 0x80,
+    0xb9, 0x50, 0x42, 0x9a, 0x95, 0xdc, 0x37, 0x24, 0xcb, 0xd4, 0x49, 0xd4, 0x6c, 0x67, 0x39, 0x14, 0x1c, 0x45, 0x49,
+    0xa7, 0x3e, 0xad, 0x0e, 0xe6, 0x5c, 0xe7, 0x96, 0xe9, 0x24, 0x7a, 0x71, 0x50, 0x17, 0x6e, 0x2f, 0xe1, 0x61, 0x39,
+    0xa4, 0x64, 0x4b, 0x3e, 0x4d, 0xc1, 0x70, 0xda, 0x1a, 0xa6, 0x9c, 0x54, 0xac, 0xdc, 0x4d, 0x05, 0x64, 0x39, 0x07,
+    0x2a, 0x11, 0xcb, 0x0f, 0x8b, 0x95, 0x94, 0x35, 0x07, 0xdd, 0x6d, 0x46, 0xdb, 0xa9, 0x37, 0x33, 0x13, 0xa7, 0x25,
+    0x19, 0x5b, 0x89, 0x29, 0x0e, 0x5b, 0x5a, 0xcd, 0x16, 0x24, 0xbd, 0x5b, 0xb6, 0xf5, 0x8a, 0x67, 0x4e, 0xaa, 0xb2,
+    0xf0, 0xf4, 0x99, 0x9f, 0x93, 0x90, 0xa6, 0xb3, 0x6e, 0x95, 0xe7, 0xf9, 0x0c, 0xa0, 0xa0, 0x8e, 0xc9, 0x6a, 0xd3,
+    0x00, 0x0f, 0x14, 0xdb, 0x99, 0x99, 0x38, 0x50, 0x1b, 0xc6, 0x46, 0x28, 0x11, 0x2f, 0x66, 0x47, 0x77, 0xbc, 0x19,
+    0xa4, 0x77, 0x01, 0x42, 0x1a, 0x88, 0x6d, 0x30, 0xf3, 0x50, 0x11, 0xc6, 0xcf, 0xad, 0x57, 0xd7, 0x64, 0xd6, 0x95,
+    0x27, 0x80, 0x45, 0xab, 0xd1, 0x45, 0x6a, 0x06, 0x05, 0xc8, 0x14, 0xd9, 0x69, 0x30, 0xf4, 0x9a, 0xed, 0x01, 0x77,
+    0x17, 0x64, 0x7f, 0xa4, 0xce, 0x4b, 0xba, 0x9d, 0x7d, 0x5c, 0x09, 0xc9, 0xf2, 0x9d, 0xd3, 0x15, 0xe9, 0x29, 0x5c,
+    0x16, 0x28, 0xce, 0x0b, 0x20, 0xa5, 0x94, 0xcf, 0xb4, 0x0e, 0x87, 0x49, 0x5a, 0x89, 0x0e, 0xa7, 0x93, 0x18, 0x7d,
+    0x41, 0x1f, 0xca, 0xfa, 0x6f, 0xd4, 0xea, 0x2e, 0xee, 0x2b, 0xd2, 0x42, 0xd1, 0x70, 0x16, 0x35, 0x60, 0x5a, 0x4d,
+    0x9d, 0x11, 0x3c, 0xab, 0x6e, 0x4b, 0x09, 0x03, 0xcf, 0xc1, 0x4c, 0x5d, 0x7b, 0x8f, 0x78, 0xfb, 0xcd, 0x16, 0x89,
+    0xba, 0x64, 0x59, 0x47, 0xa7, 0x49, 0x90, 0x77, 0x82, 0xc7, 0x87, 0xc7, 0x8d, 0xd4, 0xde, 0x11, 0xea, 0x41, 0x3e,
+    0x26, 0xbe, 0xf7, 0x99, 0x27, 0x92, 0xe5, 0x79, 0xb0, 0xc8, 0x4f, 0x48, 0xa9, 0x12, 0x7a, 0x60, 0xdd, 0xad, 0x08,
+    0x06, 0x20, 0xe0, 0xf8, 0x6c, 0x60, 0x7e, 0x60, 0x3a, 0x2c, 0xf6, 0x67, 0x52, 0xf4, 0x55, 0x9d, 0xae, 0xda, 0xd2,
+    0xb6, 0x3e, 0x73, 0x75, 0x5f, 0x84, 0x57, 0xf7, 0x25, 0xae, 0xf7, 0x74, 0x89, 0xeb, 0x21, 0xd5, 0x14, 0xbd, 0xaa,
+    0xb7, 0x49, 0x4f, 0x17, 0x9b, 0x01, 0xfc, 0xf6, 0x5e, 0x84, 0xaf, 0x81, 0xff, 0xff, 0x52, 0xbb, 0x7e, 0x77, 0xe1,
+    0xfa, 0x82, 0xaa, 0xf5, 0x85, 0x15, 0xcb, 0x78, 0xa7, 0x9c, 0x87, 0x19, 0x94, 0x26, 0x86, 0x05, 0x5b, 0xfa, 0x7f,
+    0x04, 0xb4, 0xff, 0x89, 0x63, 0x78, 0xe9, 0x8f, 0xf1, 0x04, 0xe9, 0xc1, 0x40, 0x84, 0xc3, 0x31, 0x1a, 0x5d, 0x0d,
+    0xf0, 0xc0, 0x47, 0xaa, 0x1d, 0x1a, 0xa2, 0x11, 0x1e, 0x03, 0xc1, 0x10, 0x87, 0x23, 0xd8, 0x40, 0x81, 0x8f, 0xa3,
+    0x37, 0x41, 0x88, 0x87, 0x11, 0x50, 0x05, 0x1e, 0x0e, 0x03, 0x64, 0x68, 0x87, 0x38, 0x00, 0x71, 0x8a, 0x24, 0xac,
+    0x00, 0xe8, 0x34, 0xc4, 0xde, 0x08, 0xc4, 0x0d, 0xb1, 0x37, 0xc1, 0xe3, 0x21, 0x1a, 0xe3, 0x11, 0x40, 0x87, 0x07,
+    0x51, 0xe9, 0x44, 0xd8, 0x87, 0xed, 0x70, 0x48, 0xc6, 0x78, 0x10, 0x22, 0x3d, 0x18, 0x38, 0x46, 0x20, 0xc2, 0xc1,
+    0x9e, 0xff, 0x26, 0xc4, 0xc1, 0x08, 0xf4, 0x0e, 0x06, 0x97, 0x20, 0x76, 0x32, 0x40, 0x66, 0x34, 0xf0, 0x82, 0x82,
+    0xe8, 0x29, 0xd0, 0x82, 0xbf, 0x2f, 0x68, 0x00, 0x89, 0x8f, 0x42, 0x3c, 0x81, 0xd8, 0xf5, 0x15, 0xbf, 0x19, 0x0d,
+    0x6e, 0xbe, 0x8f, 0xbc, 0xdf, 0x8d, 0x59, 0xf8, 0xf7, 0xc5, 0xcc, 0x57, 0x08, 0xc0, 0x14, 0x74, 0x83, 0x1c, 0xa4,
+    0x07, 0xa3, 0x1b, 0x98, 0xc7, 0x57, 0x13, 0x34, 0x06, 0xae, 0xe1, 0x18, 0x4d, 0x50, 0xa4, 0xd0, 0x05, 0xf6, 0x81,
+    0x61, 0x72, 0x80, 0xe9, 0x0b, 0x61, 0x1c, 0xfc, 0x85, 0x61, 0x7c, 0xca, 0xa7, 0xbf, 0xb0, 0x4b, 0x7f, 0x46, 0x0a,
+    0x82, 0x76, 0x4c, 0xb7, 0x61, 0xb1, 0x6b, 0x3e, 0x0f, 0xa8, 0x2e, 0x0a, 0xde, 0xf6, 0xa1, 0x1b, 0x99, 0xc7, 0x85,
+    0x8f, 0x58, 0x96, 0x40, 0x57, 0x3f, 0x3f, 0x6b, 0xf5, 0x81, 0xd0, 0x3f, 0x1e, 0xc1, 0xec, 0x41, 0xe3, 0x6e, 0xce,
+    0x74, 0xa5, 0x9f, 0xdf, 0x14, 0x14, 0xbd, 0xbe, 0x7e, 0x07, 0x2f, 0x7f, 0x65, 0x89, 0x78, 0xbd, 0x81, 0x77, 0xcc,
+    0x1d, 0x92, 0xb5, 0xfa, 0x6a, 0xc0, 0xa1, 0x8d, 0x54, 0x53, 0x78, 0x3d, 0x41, 0x5d, 0x1f, 0x81, 0x31, 0x8e, 0x17,
+    0xed, 0xfc, 0x5d, 0x49, 0x89, 0xa0, 0x68, 0xc9, 0xd6, 0x14, 0x31, 0x09, 0x2d, 0x42, 0x45, 0x91, 0x64, 0x6a, 0x38,
+    0x31, 0x6a, 0x3a, 0x68, 0x77, 0xb5, 0x12, 0xd3, 0x28, 0x83, 0x25, 0x20, 0x66, 0xde, 0x75, 0xc4, 0x71, 0x11, 0x1a,
+    0xab, 0xae, 0xa9, 0x94, 0xd0, 0x4c, 0x28, 0xab, 0xc2, 0x79, 0xac, 0xde, 0x6e, 0x11, 0xd1, 0xef, 0x0c, 0x89, 0xbb,
+    0x61, 0x39, 0x53, 0xdf, 0x0c, 0xe6, 0xb1, 0xee, 0x22, 0x95, 0x04, 0xd5, 0xc8, 0x98, 0x0f, 0x1c, 0x7a, 0x56, 0x52,
+    0xbe, 0x84, 0x97, 0x56, 0x78, 0x4c, 0xd0, 0x57, 0xa4, 0xb4, 0xa8, 0x4b, 0xe8, 0x5b, 0x92, 0xeb, 0xeb, 0x1f, 0xff,
+    0xa1, 0xbe, 0x86, 0x28, 0x13, 0x4e, 0x9c, 0xf0, 0x0a, 0x60, 0x18, 0xd5, 0xa4, 0xe3, 0x1b, 0x0e, 0xcc, 0x77, 0x8d,
+    0x06, 0x5a, 0x78, 0xf0, 0x2f, 0x7b, 0x20, 0xe5, 0xdd, 0x71, 0xb3, 0x93, 0xa4, 0xff, 0xeb, 0x7e, 0xd4, 0x30, 0x89,
+    0xd5, 0xa2, 0x62, 0x72, 0x7e, 0x0d, 0x06, 0xc6, 0xae, 0x39, 0x00, 0xe7, 0x94, 0x03, 0x86, 0xb6, 0xe8, 0x78, 0x00,
+    0xec, 0x9f, 0x6f, 0x2e, 0xd1, 0x2f, 0x0d, 0x5c, 0x6e, 0x6a, 0xb0, 0xd7, 0x5e, 0x56, 0x54, 0x16, 0x75, 0x96, 0xbc,
+    0xfb, 0xf9, 0xfa, 0xe6, 0xe4, 0xf1, 0x4a, 0x13, 0x21, 0xca, 0x53, 0xf3, 0xbd, 0x65, 0x55, 0x4a, 0xd6, 0x90, 0x56,
+    0x6a, 0xb1, 0x8e, 0x8a, 0x8e, 0xa3, 0x47, 0xfa, 0x3c, 0x67, 0x25, 0x35, 0x4e, 0x75, 0x8c, 0xee, 0x1c, 0x7d, 0xce,
+    0xc6, 0xa3, 0xee, 0x47, 0x56, 0xba, 0xe6, 0x02, 0xb9, 0xe6, 0x36, 0xb9, 0xfa, 0x6b, 0xd4, 0xbf, 0x01, 0x14, 0xee,
+    0xbc, 0x64, 0x9d, 0x12, 0x00, 0x00};
 
 }  // namespace captive_portal
 }  // namespace esphome

esphome/components/captive_portal/captive_portal.cpp

@@ -12,7 +12,7 @@ static const char *const TAG = "captive_portal";
 void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream("application/json");
   stream->addHeader("cache-control", "public, max-age=0, must-revalidate");
-  stream->printf(R"({"name":"%s","aps":[{})", App.get_name().c_str());
+  stream->printf(R"({"mac":"%s","name":"%s","aps":[{})", get_mac_address_pretty().c_str(), App.get_name().c_str());
 
   for (auto &scan : wifi::global_wifi_component->get_scan_result()) {
     if (scan.get_is_hidden())

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:
-        cg.add(var.set_visual_min_temperature_override(visual[CONF_MIN_TEMPERATURE]))
-    if CONF_MAX_TEMPERATURE in visual:
-        cg.add(var.set_visual_max_temperature_override(visual[CONF_MAX_TEMPERATURE]))
-    if CONF_TEMPERATURE_STEP in visual:
+    if (min_temp := visual.get(CONF_MIN_TEMPERATURE)) is not None:
+        cg.add(var.set_visual_min_temperature_override(min_temp))
+    if (max_temp := visual.get(CONF_MAX_TEMPERATURE)) is not None:
+        cg.add(var.set_visual_max_temperature_override(max_temp))
+    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],
-                visual[CONF_TEMPERATURE_STEP][CONF_CURRENT_TEMPERATURE],
+                temp_step[CONF_TARGET_TEMPERATURE],
+                temp_step[CONF_CURRENT_TEMPERATURE],
             )
         )
-    if CONF_MIN_HUMIDITY in visual:
-        cg.add(var.set_visual_min_humidity_override(visual[CONF_MIN_HUMIDITY]))
-    if CONF_MAX_HUMIDITY in visual:
-        cg.add(var.set_visual_max_humidity_override(visual[CONF_MAX_HUMIDITY]))
+    if (min_humidity := visual.get(CONF_MIN_HUMIDITY)) is not None:
+        cg.add(var.set_visual_min_humidity_override(min_humidity))
+    if (max_humidity := visual.get(CONF_MAX_HUMIDITY)) is not None:
+        cg.add(var.set_visual_max_humidity_override(max_humidity))
 
-    if CONF_MQTT_ID in config:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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_ACTION_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_action_state_topic(config[CONF_ACTION_STATE_TOPIC]))
-        if CONF_AWAY_COMMAND_TOPIC in config:
-            cg.add(mqtt_.set_custom_away_command_topic(config[CONF_AWAY_COMMAND_TOPIC]))
-        if CONF_AWAY_STATE_TOPIC in config:
-            cg.add(mqtt_.set_custom_away_state_topic(config[CONF_AWAY_STATE_TOPIC]))
-        if CONF_CURRENT_TEMPERATURE_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(action_state_topic))
+        if (away_command_topic := config.get(CONF_AWAY_COMMAND_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_away_command_topic(away_command_topic))
+        if (away_state_topic := config.get(CONF_AWAY_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_away_state_topic(away_state_topic))
+        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:
-            cg.add(
-                mqtt_.set_custom_fan_mode_command_topic(
-                    config[CONF_FAN_MODE_COMMAND_TOPIC]
-                )
+        if (
+            fan_mode_command_topic := config.get(CONF_FAN_MODE_COMMAND_TOPIC)
+        ) is not None:
+            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
             )
-        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:
+        ) is not None:
             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:
-        template_ = await cg.templatable(config[CONF_MODE], args, ClimateMode)
+    if (mode := config.get(CONF_MODE)) is not None:
+        template_ = await cg.templatable(mode, args, ClimateMode)
         cg.add(var.set_mode(template_))
-    if CONF_TARGET_TEMPERATURE in config:
-        template_ = await cg.templatable(config[CONF_TARGET_TEMPERATURE], args, float)
+    if (target_temp := config.get(CONF_TARGET_TEMPERATURE)) is not None:
+        template_ = await cg.templatable(target_temp, args, float)
         cg.add(var.set_target_temperature(template_))
-    if CONF_TARGET_TEMPERATURE_LOW in config:
-        template_ = await cg.templatable(
-            config[CONF_TARGET_TEMPERATURE_LOW], args, float
-        )
+    if (target_temp_low := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
+        template_ = await cg.templatable(target_temp_low, args, float)
         cg.add(var.set_target_temperature_low(template_))
-    if CONF_TARGET_TEMPERATURE_HIGH in config:
-        template_ = await cg.templatable(
-            config[CONF_TARGET_TEMPERATURE_HIGH], args, float
-        )
+    if (target_temp_high := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
+        template_ = await cg.templatable(target_temp_high, args, float)
         cg.add(var.set_target_temperature_high(template_))
-    if CONF_TARGET_HUMIDITY in config:
-        template_ = await cg.templatable(config[CONF_TARGET_HUMIDITY], args, float)
+    if (target_humidity := config.get(CONF_TARGET_HUMIDITY)) is not None:
+        template_ = await cg.templatable(target_humidity, args, float)
         cg.add(var.set_target_humidity(template_))
-    if CONF_FAN_MODE in config:
-        template_ = await cg.templatable(config[CONF_FAN_MODE], args, ClimateFanMode)
+    if (fan_mode := config.get(CONF_FAN_MODE)) is not None:
+        template_ = await cg.templatable(fan_mode, args, ClimateFanMode)
         cg.add(var.set_fan_mode(template_))
-    if CONF_CUSTOM_FAN_MODE in config:
-        template_ = await cg.templatable(
-            config[CONF_CUSTOM_FAN_MODE], args, cg.std_string
-        )
+    if (custom_fan_mode := config.get(CONF_CUSTOM_FAN_MODE)) is not None:
+        template_ = await cg.templatable(custom_fan_mode, args, cg.std_string)
         cg.add(var.set_custom_fan_mode(template_))
-    if CONF_PRESET in config:
-        template_ = await cg.templatable(config[CONF_PRESET], args, ClimatePreset)
+    if (preset := config.get(CONF_PRESET)) is not None:
+        template_ = await cg.templatable(preset, args, ClimatePreset)
         cg.add(var.set_preset(template_))
-    if CONF_CUSTOM_PRESET in config:
-        template_ = await cg.templatable(
-            config[CONF_CUSTOM_PRESET], args, cg.std_string
-        )
+    if (custom_preset := config.get(CONF_CUSTOM_PRESET)) is not None:
+        template_ = await cg.templatable(custom_preset, args, cg.std_string)
         cg.add(var.set_custom_preset(template_))
-    if CONF_SWING_MODE in config:
-        template_ = await cg.templatable(
-            config[CONF_SWING_MODE], args, ClimateSwingMode
-        )
+    if (swing_mode := config.get(CONF_SWING_MODE)) is not None:
+        template_ = await cg.templatable(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:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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_POSITION_STATE_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_position_state_topic(config[CONF_POSITION_STATE_TOPIC])
-            )
-        if CONF_POSITION_COMMAND_TOPIC in config:
-            cg.add(
-                mqtt_.set_custom_position_command_topic(
-                    config[CONF_POSITION_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]))
+        if (position_state_topic := config.get(CONF_POSITION_STATE_TOPIC)) is not None:
+            cg.add(mqtt_.set_custom_position_state_topic(position_state_topic))
+        if (
+            position_command_topic := config.get(CONF_POSITION_COMMAND_TOPIC)
+        ) is not None:
+            cg.add(mqtt_.set_custom_position_command_topic(position_command_topic))
+        if (tilt_state_topic := config.get(CONF_TILT_STATE_TOPIC)) is not None:
+            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))
 
 
 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:
-        template_ = await cg.templatable(config[CONF_STOP], args, bool)
+    if (stop := config.get(CONF_STOP)) is not None:
+        template_ = await cg.templatable(stop, args, bool)
         cg.add(var.set_stop(template_))
-    if CONF_STATE in config:
-        template_ = await cg.templatable(config[CONF_STATE], args, float)
+    if (state := config.get(CONF_STATE)) is not None:
+        template_ = await cg.templatable(state, args, float)
         cg.add(var.set_position(template_))
-    if CONF_POSITION in config:
-        template_ = await cg.templatable(config[CONF_POSITION], args, float)
+    if (position := config.get(CONF_POSITION)) is not None:
+        template_ = await cg.templatable(position, args, float)
         cg.add(var.set_position(template_))
-    if CONF_TILT in config:
-        template_ = await cg.templatable(config[CONF_TILT], args, float)
+    if (tilt := config.get(CONF_TILT)) is not None:
+        template_ = await cg.templatable(tilt, args, float)
         cg.add(var.set_tilt(template_))
     return var
 

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) {
-    ESP_LOGE(TAG, "Requesting conversion failed");
-    this->status_set_warning();
+    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

@@ -3,38 +3,50 @@ import esphome.codegen as cg
 # import cpp_generator as cpp
 import esphome.config_validation as cv
 from esphome import automation
-from esphome.components import mqtt
+from esphome.components import mqtt, time
 from esphome.const import (
     CONF_ID,
+    CONF_ON_TIME,
     CONF_ON_VALUE,
+    CONF_TIME_ID,
     CONF_TRIGGER_ID,
     CONF_TYPE,
     CONF_MQTT_ID,
     CONF_DATE,
+    CONF_TIME,
     CONF_YEAR,
     CONF_MONTH,
     CONF_DAY,
+    CONF_SECOND,
+    CONF_HOUR,
+    CONF_MINUTE,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 
-CODEOWNERS = ["@rfdarter"]
+CODEOWNERS = ["@rfdarter", "@jesserockz"]
 
 IS_PLATFORM_COMPONENT = True
 
 datetime_ns = cg.esphome_ns.namespace("datetime")
 DateTimeBase = datetime_ns.class_("DateTimeBase", cg.EntityBase)
 DateEntity = datetime_ns.class_("DateEntity", DateTimeBase)
+TimeEntity = datetime_ns.class_("TimeEntity", DateTimeBase)
 
 # Actions
 DateSetAction = datetime_ns.class_("DateSetAction", automation.Action)
+TimeSetAction = datetime_ns.class_("TimeSetAction", automation.Action)
 
 DateTimeStateTrigger = datetime_ns.class_(
     "DateTimeStateTrigger", automation.Trigger.template(cg.ESPTime)
 )
 
+OnTimeTrigger = datetime_ns.class_(
+    "OnTimeTrigger", automation.Trigger, cg.Component, cg.Parented.template(TimeEntity)
+)
+
 DATETIME_MODES = [
     "DATE",
     "TIME",
@@ -44,7 +56,6 @@ DATETIME_MODES = [
 
 _DATETIME_SCHEMA = cv.Schema(
     {
-        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTDatetimeComponent),
         cv.Optional(CONF_ON_VALUE): automation.validate_automation(
             {
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(DateTimeStateTrigger),
@@ -57,6 +68,7 @@ _DATETIME_SCHEMA = cv.Schema(
 def date_schema(class_: MockObjClass) -> cv.Schema:
     schema = {
         cv.GenerateID(): cv.declare_id(class_),
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTDateComponent),
         cv.Optional(CONF_TYPE, default="DATE"): cv.one_of("DATE", upper=True),
     }
     return _DATETIME_SCHEMA.extend(schema)
@@ -65,7 +77,20 @@ def date_schema(class_: MockObjClass) -> cv.Schema:
 def time_schema(class_: MockObjClass) -> cv.Schema:
     schema = {
         cv.GenerateID(): cv.declare_id(class_),
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTTimeComponent),
         cv.Optional(CONF_TYPE, default="TIME"): cv.one_of("TIME", upper=True),
+        cv.Inclusive(
+            CONF_ON_TIME,
+            group_of_inclusion=CONF_ON_TIME,
+            msg="`on_time` and `time_id` must both be specified",
+        ): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnTimeTrigger),
+            }
+        ),
+        cv.Inclusive(CONF_TIME_ID, group_of_inclusion=CONF_ON_TIME): cv.use_id(
+            time.RealTimeClock
+        ),
     }
     return _DATETIME_SCHEMA.extend(schema)
 
@@ -81,13 +106,24 @@ 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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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)
     for conf in config.get(CONF_ON_VALUE, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [(cg.ESPTime, "x")], conf)
 
+    rtc_id = config.get(CONF_TIME_ID)
+    rtc = None
+    if rtc_id is not None:
+        rtc = await cg.get_variable(rtc_id)
+    for conf in config.get(CONF_ON_TIME, []):
+        assert rtc is not None
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], rtc)
+        await automation.build_automation(trigger, [], conf)
+        await cg.register_component(trigger, conf)
+        await cg.register_parented(trigger, var)
+
 
 async def register_datetime(var, config):
     if not CORE.has_id(config[CONF_ID]):
@@ -109,18 +145,12 @@ async def to_code(config):
     cg.add_global(datetime_ns.using)
 
 
-OPERATION_BASE_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_ID): cv.use_id(DateEntity),
-    }
-)
-
-
 @automation.register_action(
     "datetime.date.set",
     DateSetAction,
-    OPERATION_BASE_SCHEMA.extend(
+    cv.Schema(
         {
+            cv.Required(CONF_ID): cv.use_id(DateEntity),
             cv.Required(CONF_DATE): cv.Any(
                 cv.returning_lambda, cv.date_time(allowed_time=False)
             ),
@@ -144,3 +174,34 @@ async def datetime_date_set_to_code(config, action_id, template_arg, args):
         )
         cg.add(action_var.set_date(date_struct))
     return action_var
+
+
+@automation.register_action(
+    "datetime.time.set",
+    TimeSetAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(TimeEntity),
+            cv.Required(CONF_TIME): cv.Any(
+                cv.returning_lambda, cv.date_time(allowed_date=False)
+            ),
+        }
+    ),
+)
+async def datetime_time_set_to_code(config, action_id, template_arg, args):
+    action_var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(action_var, config[CONF_ID])
+
+    time_config = config[CONF_TIME]
+    if cg.is_template(time_config):
+        template_ = await cg.templatable(config[CONF_TIME], [], cg.ESPTime)
+        cg.add(action_var.set_time(template_))
+    else:
+        time_struct = cg.StructInitializer(
+            cg.ESPTime,
+            ("second", time_config[CONF_SECOND]),
+            ("minute", time_config[CONF_MINUTE]),
+            ("hour", time_config[CONF_HOUR]),
+        )
+        cg.add(action_var.set_time(time_struct))
+    return action_var

esphome/components/datetime/time_entity.cpp

@@ -0,0 +1,156 @@
+#include "time_entity.h"
+
+#ifdef USE_DATETIME_TIME
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace datetime {
+
+static const char *const TAG = "datetime.time_entity";
+
+void TimeEntity::publish_state() {
+  if (this->hour_ > 23) {
+    this->has_state_ = false;
+    ESP_LOGE(TAG, "Hour must be between 0 and 23");
+    return;
+  }
+  if (this->minute_ > 59) {
+    this->has_state_ = false;
+    ESP_LOGE(TAG, "Minute must be between 0 and 59");
+    return;
+  }
+  if (this->second_ > 59) {
+    this->has_state_ = false;
+    ESP_LOGE(TAG, "Second must be between 0 and 59");
+    return;
+  }
+  this->has_state_ = true;
+  ESP_LOGD(TAG, "'%s': Sending time %02d:%02d:%02d", this->get_name().c_str(), this->hour_, this->minute_,
+           this->second_);
+  this->state_callback_.call();
+}
+
+TimeCall TimeEntity::make_call() { return TimeCall(this); }
+
+void TimeCall::validate_() {
+  if (this->hour_.has_value() && this->hour_ > 23) {
+    ESP_LOGE(TAG, "Hour must be between 0 and 23");
+    this->hour_.reset();
+  }
+  if (this->minute_.has_value() && this->minute_ > 59) {
+    ESP_LOGE(TAG, "Minute must be between 0 and 59");
+    this->minute_.reset();
+  }
+  if (this->second_.has_value() && this->second_ > 59) {
+    ESP_LOGE(TAG, "Second must be between 0 and 59");
+    this->second_.reset();
+  }
+}
+
+void TimeCall::perform() {
+  this->validate_();
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  if (this->hour_.has_value()) {
+    ESP_LOGD(TAG, " Hour: %d", *this->hour_);
+  }
+  if (this->minute_.has_value()) {
+    ESP_LOGD(TAG, " Minute: %d", *this->minute_);
+  }
+  if (this->second_.has_value()) {
+    ESP_LOGD(TAG, " Second: %d", *this->second_);
+  }
+  this->parent_->control(*this);
+}
+
+TimeCall &TimeCall::set_time(uint8_t hour, uint8_t minute, uint8_t second) {
+  this->hour_ = hour;
+  this->minute_ = minute;
+  this->second_ = second;
+  return *this;
+};
+
+TimeCall &TimeCall::set_time(ESPTime time) { return this->set_time(time.hour, time.minute, time.second); };
+
+TimeCall &TimeCall::set_time(const std::string &time) {
+  ESPTime val{};
+  if (!ESPTime::strptime(time, val)) {
+    ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
+    return *this;
+  }
+  return this->set_time(val);
+}
+
+TimeCall TimeEntityRestoreState::to_call(TimeEntity *time) {
+  TimeCall call = time->make_call();
+  call.set_time(this->hour, this->minute, this->second);
+  return call;
+}
+
+void TimeEntityRestoreState::apply(TimeEntity *time) {
+  time->hour_ = this->hour;
+  time->minute_ = this->minute;
+  time->second_ = this->second;
+  time->publish_state();
+}
+
+#ifdef USE_TIME
+
+static const int MAX_TIMESTAMP_DRIFT = 900;  // how far can the clock drift before we consider
+                                             // there has been a drastic time synchronization
+
+void OnTimeTrigger::loop() {
+  if (!this->parent_->has_state()) {
+    return;
+  }
+  ESPTime time = this->rtc_->now();
+  if (!time.is_valid()) {
+    return;
+  }
+  if (this->last_check_.has_value()) {
+    if (*this->last_check_ > time && this->last_check_->timestamp - time.timestamp > MAX_TIMESTAMP_DRIFT) {
+      // We went back in time (a lot), probably caused by time synchronization
+      ESP_LOGW(TAG, "Time has jumped back!");
+    } else if (*this->last_check_ >= time) {
+      // already handled this one
+      return;
+    } else if (time > *this->last_check_ && time.timestamp - this->last_check_->timestamp > MAX_TIMESTAMP_DRIFT) {
+      // We went ahead in time (a lot), probably caused by time synchronization
+      ESP_LOGW(TAG, "Time has jumped ahead!");
+      this->last_check_ = time;
+      return;
+    }
+
+    while (true) {
+      this->last_check_->increment_second();
+      if (*this->last_check_ >= time)
+        break;
+
+      if (this->matches_(*this->last_check_)) {
+        this->trigger();
+        break;
+      }
+    }
+  }
+
+  this->last_check_ = time;
+  if (!time.fields_in_range()) {
+    ESP_LOGW(TAG, "Time is out of range!");
+    ESP_LOGD(TAG, "Second=%02u Minute=%02u Hour=%02u", time.second, time.minute, time.hour);
+  }
+
+  if (this->matches_(time))
+    this->trigger();
+}
+
+bool OnTimeTrigger::matches_(const ESPTime &time) const {
+  return time.is_valid() && time.hour == this->parent_->hour && time.minute == this->parent_->minute &&
+         time.second == this->parent_->second;
+}
+
+#endif
+
+}  // namespace datetime
+}  // namespace esphome
+
+#endif  // USE_DATETIME_TIME

esphome/components/datetime/time_entity.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_DATETIME_TIME
+
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/time.h"
+
+#include "datetime_base.h"
+
+#ifdef USE_TIME
+#include "esphome/components/time/real_time_clock.h"
+#endif
+
+namespace esphome {
+namespace datetime {
+
+#define LOG_DATETIME_TIME(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()); \
+    } \
+  }
+
+class TimeCall;
+class TimeEntity;
+
+struct TimeEntityRestoreState {
+  uint8_t hour;
+  uint8_t minute;
+  uint8_t second;
+
+  TimeCall to_call(TimeEntity *time);
+  void apply(TimeEntity *time);
+} __attribute__((packed));
+
+class TimeEntity : public DateTimeBase {
+ protected:
+  uint8_t hour_;
+  uint8_t minute_;
+  uint8_t second_;
+
+ public:
+  void publish_state();
+  TimeCall make_call();
+
+  ESPTime state_as_esptime() const override {
+    ESPTime obj;
+    obj.hour = this->hour_;
+    obj.minute = this->minute_;
+    obj.second = this->second_;
+    return obj;
+  }
+
+  const uint8_t &hour = hour_;
+  const uint8_t &minute = minute_;
+  const uint8_t &second = second_;
+
+ protected:
+  friend class TimeCall;
+  friend struct TimeEntityRestoreState;
+
+  virtual void control(const TimeCall &call) = 0;
+};
+
+class TimeCall {
+ public:
+  explicit TimeCall(TimeEntity *parent) : parent_(parent) {}
+  void perform();
+  TimeCall &set_time(uint8_t hour, uint8_t minute, uint8_t second);
+  TimeCall &set_time(ESPTime time);
+  TimeCall &set_time(const std::string &time);
+
+  TimeCall &set_hour(uint8_t hour) {
+    this->hour_ = hour;
+    return *this;
+  }
+  TimeCall &set_minute(uint8_t minute) {
+    this->minute_ = minute;
+    return *this;
+  }
+  TimeCall &set_second(uint8_t second) {
+    this->second_ = second;
+    return *this;
+  }
+
+  optional<uint8_t> get_hour() const { return this->hour_; }
+  optional<uint8_t> get_minute() const { return this->minute_; }
+  optional<uint8_t> get_second() const { return this->second_; }
+
+ protected:
+  void validate_();
+
+  TimeEntity *parent_;
+
+  optional<uint8_t> hour_;
+  optional<uint8_t> minute_;
+  optional<uint8_t> second_;
+};
+
+template<typename... Ts> class TimeSetAction : public Action<Ts...>, public Parented<TimeEntity> {
+ public:
+  TEMPLATABLE_VALUE(ESPTime, time)
+
+  void play(Ts... x) override {
+    auto call = this->parent_->make_call();
+
+    if (this->time_.has_value()) {
+      call.set_time(this->time_.value(x...));
+    }
+    call.perform();
+  }
+};
+
+#ifdef USE_TIME
+
+class OnTimeTrigger : public Trigger<>, public Component, public Parented<TimeEntity> {
+ public:
+  explicit OnTimeTrigger(time::RealTimeClock *rtc) : rtc_(rtc) {}
+  void loop() override;
+
+ protected:
+  bool matches_(const ESPTime &time) const;
+
+  time::RealTimeClock *rtc_;
+  optional<ESPTime> last_check_;
+};
+
+#endif
+
+}  // namespace datetime
+}  // namespace esphome
+
+#endif  // USE_DATETIME_TIME

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

@@ -0,0 +1,55 @@
+import esphome.config_validation as cv
+import esphome.codegen as cg
+
+from esphome.components import esp32
+
+CODEOWNERS = ["@jesserockz"]
+
+RMT_TX_CHANNELS = {
+    esp32.const.VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7],
+    esp32.const.VARIANT_ESP32S2: [0, 1, 2, 3],
+    esp32.const.VARIANT_ESP32S3: [0, 1, 2, 3],
+    esp32.const.VARIANT_ESP32C3: [0, 1],
+    esp32.const.VARIANT_ESP32C6: [0, 1],
+    esp32.const.VARIANT_ESP32H2: [0, 1],
+}
+
+RMT_RX_CHANNELS = {
+    esp32.const.VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7],
+    esp32.const.VARIANT_ESP32S2: [0, 1, 2, 3],
+    esp32.const.VARIANT_ESP32S3: [4, 5, 6, 7],
+    esp32.const.VARIANT_ESP32C3: [2, 3],
+    esp32.const.VARIANT_ESP32C6: [2, 3],
+    esp32.const.VARIANT_ESP32H2: [2, 3],
+}
+
+rmt_channel_t = cg.global_ns.enum("rmt_channel_t")
+RMT_CHANNEL_ENUMS = {
+    0: rmt_channel_t.RMT_CHANNEL_0,
+    1: rmt_channel_t.RMT_CHANNEL_1,
+    2: rmt_channel_t.RMT_CHANNEL_2,
+    3: rmt_channel_t.RMT_CHANNEL_3,
+    4: rmt_channel_t.RMT_CHANNEL_4,
+    5: rmt_channel_t.RMT_CHANNEL_5,
+    6: rmt_channel_t.RMT_CHANNEL_6,
+    7: rmt_channel_t.RMT_CHANNEL_7,
+}
+
+
+def validate_rmt_channel(*, tx: bool):
+
+    rmt_channels = RMT_TX_CHANNELS if tx else RMT_RX_CHANNELS
+
+    def _validator(value):
+        cv.only_on_esp32(value)
+        value = cv.int_(value)
+        variant = esp32.get_esp32_variant()
+        if variant not in rmt_channels:
+            raise cv.Invalid(f"ESP32 variant {variant} does not support RMT.")
+        if value not in rmt_channels[variant]:
+            raise cv.Invalid(
+                f"RMT channel {value} does not support {'transmitting' if tx else 'receiving'} for ESP32 variant {variant}."
+            )
+        return cv.enum(RMT_CHANNEL_ENUMS)(value)
+
+    return _validator

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

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.components import esp32, light
+from esphome.components import esp32_rmt, light
 from esphome.const import (
     CONF_CHIPSET,
     CONF_MAX_REFRESH_RATE,
@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_OUTPUT_ID,
     CONF_PIN,
     CONF_RGB_ORDER,
+    CONF_RMT_CHANNEL,
 )
 
 CODEOWNERS = ["@jesserockz"]
@@ -47,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),
 }
 
 
@@ -57,27 +58,6 @@ CONF_BIT0_HIGH = "bit0_high"
 CONF_BIT0_LOW = "bit0_low"
 CONF_BIT1_HIGH = "bit1_high"
 CONF_BIT1_LOW = "bit1_low"
-CONF_RMT_CHANNEL = "rmt_channel"
-
-RMT_CHANNELS = {
-    esp32.const.VARIANT_ESP32: [0, 1, 2, 3, 4, 5, 6, 7],
-    esp32.const.VARIANT_ESP32S2: [0, 1, 2, 3],
-    esp32.const.VARIANT_ESP32S3: [0, 1, 2, 3],
-    esp32.const.VARIANT_ESP32C3: [0, 1],
-    esp32.const.VARIANT_ESP32C6: [0, 1],
-    esp32.const.VARIANT_ESP32H2: [0, 1],
-}
-
-
-def _validate_rmt_channel(value):
-    variant = esp32.get_esp32_variant()
-    if variant not in RMT_CHANNELS:
-        raise cv.Invalid(f"ESP32 variant {variant} does not support RMT.")
-    if value not in RMT_CHANNELS[variant]:
-        raise cv.Invalid(
-            f"RMT channel {value} is not supported for ESP32 variant {variant}."
-        )
-    return value
 
 
 CONFIG_SCHEMA = cv.All(
@@ -87,7 +67,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_PIN): pins.internal_gpio_output_pin_number,
             cv.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
             cv.Required(CONF_RGB_ORDER): cv.enum(RGB_ORDERS, upper=True),
-            cv.Required(CONF_RMT_CHANNEL): _validate_rmt_channel,
+            cv.Required(CONF_RMT_CHANNEL): esp32_rmt.validate_rmt_channel(tx=True),
             cv.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
             cv.Optional(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
             cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,

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/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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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_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(
-                    config[CONF_OSCILLATION_STATE_TOPIC]
-                )
+                mqtt_.set_custom_oscillation_command_topic(oscillation_command_topic)
             )
-        if CONF_OSCILLATION_COMMAND_TOPIC in config:
+        if (
+            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(
-                    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])
+                mqtt_.set_custom_speed_level_command_topic(speed_level_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:
-        template_ = await cg.templatable(config[CONF_OSCILLATING], args, bool)
+    if (oscillating := config.get(CONF_OSCILLATING)) is not None:
+        template_ = await cg.templatable(oscillating, args, bool)
         cg.add(var.set_oscillating(template_))
-    if CONF_SPEED in config:
-        template_ = await cg.templatable(config[CONF_SPEED], args, int)
+    if (speed := config.get(CONF_SPEED)) is not None:
+        template_ = await cg.templatable(speed, args, int)
         cg.add(var.set_speed(template_))
-    if CONF_DIRECTION in config:
-        template_ = await cg.templatable(config[CONF_DIRECTION], args, FanDirection)
+    if (direction := config.get(CONF_DIRECTION)) is not None:
+        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 = height
+            max_height = max(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/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%% Heater Level=%d", humidity, heater_level);
+      ESP_LOGD(TAG, "Got Humidity=%.1f%%", humidity);
 
       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/i2c/__init__.py

@@ -4,6 +4,7 @@ import esphome.final_validate as fv
 from esphome import pins
 from esphome.const import (
     CONF_FREQUENCY,
+    CONF_TIMEOUT,
     CONF_ID,
     CONF_INPUT,
     CONF_OUTPUT,
@@ -59,6 +60,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_FREQUENCY, default="50kHz"): cv.All(
                 cv.frequency, cv.Range(min=0, min_included=False)
             ),
+            cv.Optional(CONF_TIMEOUT): cv.positive_time_period,
             cv.Optional(CONF_SCAN, default=True): cv.boolean,
         }
     ).extend(cv.COMPONENT_SCHEMA),
@@ -81,6 +83,8 @@ async def to_code(config):
 
     cg.add(var.set_frequency(int(config[CONF_FREQUENCY])))
     cg.add(var.set_scan(config[CONF_SCAN]))
+    if CONF_TIMEOUT in config:
+        cg.add(var.set_timeout(int(config[CONF_TIMEOUT].total_microseconds)))
     if CORE.using_arduino:
         cg.add_library("Wire", None)
 
@@ -119,23 +123,56 @@ async def register_i2c_device(var, config):
 
 
 def final_validate_device_schema(
-    name: str, *, min_frequency: cv.frequency = None, max_frequency: cv.frequency = None
+    name: str,
+    *,
+    min_frequency: cv.frequency = None,
+    max_frequency: cv.frequency = None,
+    min_timeout: cv.time_period = None,
+    max_timeout: cv.time_period = None,
 ):
     hub_schema = {}
-    if min_frequency is not None:
+    if (min_frequency is not None) and (max_frequency is not None):
+        hub_schema[cv.Required(CONF_FREQUENCY)] = cv.Range(
+            min=cv.frequency(min_frequency),
+            min_included=True,
+            max=cv.frequency(max_frequency),
+            max_included=True,
+            msg=f"Component {name} requires a frequency between {min_frequency} and {max_frequency} for the I2C bus",
+        )
+    elif min_frequency is not None:
         hub_schema[cv.Required(CONF_FREQUENCY)] = cv.Range(
             min=cv.frequency(min_frequency),
             min_included=True,
             msg=f"Component {name} requires a minimum frequency of {min_frequency} for the I2C bus",
         )
-
-    if max_frequency is not None:
+    elif max_frequency is not None:
         hub_schema[cv.Required(CONF_FREQUENCY)] = cv.Range(
             max=cv.frequency(max_frequency),
             max_included=True,
             msg=f"Component {name} cannot be used with a frequency of over {max_frequency} for the I2C bus",
         )
 
+    if (min_timeout is not None) and (max_timeout is not None):
+        hub_schema[cv.Required(CONF_TIMEOUT)] = cv.Range(
+            min=cv.time_period(min_timeout),
+            min_included=True,
+            max=cv.time_period(max_timeout),
+            max_included=True,
+            msg=f"Component {name} requires a timeout between {min_timeout} and {max_timeout} for the I2C bus",
+        )
+    elif min_timeout is not None:
+        hub_schema[cv.Required(CONF_TIMEOUT)] = cv.Range(
+            min=cv.time_period(min_timeout),
+            min_included=True,
+            msg=f"Component {name} requires a minimum timeout of {min_timeout} for the I2C bus",
+        )
+    elif max_timeout is not None:
+        hub_schema[cv.Required(CONF_TIMEOUT)] = cv.Range(
+            max=cv.time_period(max_timeout),
+            max_included=True,
+            msg=f"Component {name} cannot be used with a timeout of over {max_timeout} for the I2C bus",
+        )
+
     return cv.Schema(
         {cv.Required(CONF_I2C_ID): fv.id_declaration_match_schema(hub_schema)},
         extra=cv.ALLOW_EXTRA,

esphome/components/i2c/i2c_bus_arduino.cpp

@@ -52,6 +52,18 @@ void ArduinoI2CBus::set_pins_and_clock_() {
 #else
   wire_->begin(static_cast<int>(sda_pin_), static_cast<int>(scl_pin_));
 #endif
+  if (timeout_ > 0) {  // if timeout specified in yaml
+#if defined(USE_ESP32)
+    // https://github.com/espressif/arduino-esp32/blob/master/libraries/Wire/src/Wire.cpp
+    wire_->setTimeOut(timeout_ / 1000);  // unit: ms
+#elif defined(USE_ESP8266)
+    // https://github.com/esp8266/Arduino/blob/master/libraries/Wire/Wire.h
+    wire_->setClockStretchLimit(timeout_);  // unit: us
+#elif defined(USE_RP2040)
+    // https://github.com/earlephilhower/ArduinoCore-API/blob/e37df85425e0ac020bfad226d927f9b00d2e0fb7/api/Stream.h
+    wire_->setTimeout(timeout_ / 1000);  // unit: ms
+#endif
+  }
   wire_->setClock(frequency_);
 }
 
@@ -60,6 +72,15 @@ void ArduinoI2CBus::dump_config() {
   ESP_LOGCONFIG(TAG, "  SDA Pin: GPIO%u", this->sda_pin_);
   ESP_LOGCONFIG(TAG, "  SCL Pin: GPIO%u", this->scl_pin_);
   ESP_LOGCONFIG(TAG, "  Frequency: %u Hz", this->frequency_);
+  if (timeout_ > 0) {
+#if defined(USE_ESP32)
+    ESP_LOGCONFIG(TAG, "  Timeout: %u ms", this->timeout_ / 1000);
+#elif defined(USE_ESP8266)
+    ESP_LOGCONFIG(TAG, "  Timeout: %u us", this->timeout_);
+#elif defined(USE_RP2040)
+    ESP_LOGCONFIG(TAG, "  Timeout: %u ms", this->timeout_ / 1000);
+#endif
+  }
   switch (this->recovery_result_) {
     case RECOVERY_COMPLETED:
       ESP_LOGCONFIG(TAG, "  Recovery: bus successfully recovered");

esphome/components/i2c/i2c_bus_arduino.h

@@ -27,6 +27,7 @@ class ArduinoI2CBus : public I2CBus, public Component {
   void set_sda_pin(uint8_t sda_pin) { sda_pin_ = sda_pin; }
   void set_scl_pin(uint8_t scl_pin) { scl_pin_ = scl_pin; }
   void set_frequency(uint32_t frequency) { frequency_ = frequency; }
+  void set_timeout(uint32_t timeout) { timeout_ = timeout; }
 
  private:
   void recover_();
@@ -38,6 +39,7 @@ class ArduinoI2CBus : public I2CBus, public Component {
   uint8_t sda_pin_;
   uint8_t scl_pin_;
   uint32_t frequency_;
+  uint32_t timeout_ = 0;
   bool initialized_ = false;
 };
 

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -1,12 +1,12 @@
 #ifdef USE_ESP_IDF
 
 #include "i2c_bus_esp_idf.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/application.h"
-#include <cstring>
 #include <cinttypes>
+#include <cstring>
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace i2c {
@@ -45,6 +45,20 @@ void IDFI2CBus::setup() {
     this->mark_failed();
     return;
   }
+  if (timeout_ > 0) {  // if timeout specified in yaml:
+    if (timeout_ > 13000) {
+      ESP_LOGW(TAG, "i2c timeout of %" PRIu32 "us greater than max of 13ms on esp-idf, setting to max", timeout_);
+      timeout_ = 13000;
+    }
+    err = i2c_set_timeout(port_, timeout_ * 80);  // unit: APB 80MHz clock cycle
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "i2c_set_timeout failed: %s", esp_err_to_name(err));
+      this->mark_failed();
+      return;
+    } else {
+      ESP_LOGV(TAG, "i2c_timeout set to %d ticks (%d us)", timeout_ * 80, timeout_);
+    }
+  }
   err = i2c_driver_install(port_, I2C_MODE_MASTER, 0, 0, ESP_INTR_FLAG_IRAM);
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "i2c_driver_install failed: %s", esp_err_to_name(err));
@@ -62,6 +76,9 @@ void IDFI2CBus::dump_config() {
   ESP_LOGCONFIG(TAG, "  SDA Pin: GPIO%u", this->sda_pin_);
   ESP_LOGCONFIG(TAG, "  SCL Pin: GPIO%u", this->scl_pin_);
   ESP_LOGCONFIG(TAG, "  Frequency: %" PRIu32 " Hz", this->frequency_);
+  if (timeout_ > 0) {
+    ESP_LOGCONFIG(TAG, "  Timeout: %" PRIu32 "us", this->timeout_);
+  }
   switch (this->recovery_result_) {
     case RECOVERY_COMPLETED:
       ESP_LOGCONFIG(TAG, "  Recovery: bus successfully recovered");
@@ -127,6 +144,8 @@ ErrorCode IDFI2CBus::readv(uint8_t address, ReadBuffer *buffers, size_t cnt) {
     return ERROR_UNKNOWN;
   }
   err = i2c_master_cmd_begin(port_, cmd, 20 / portTICK_PERIOD_MS);
+  // i2c_master_cmd_begin() will block for a whole second if no ack:
+  // https://github.com/espressif/esp-idf/issues/4999
   i2c_cmd_link_delete(cmd);
   if (err == ESP_FAIL) {
     // transfer not acked

esphome/components/i2c/i2c_bus_esp_idf.h

@@ -29,6 +29,7 @@ class IDFI2CBus : public I2CBus, public Component {
   void set_scl_pin(uint8_t scl_pin) { scl_pin_ = scl_pin; }
   void set_scl_pullup_enabled(bool scl_pullup_enabled) { scl_pullup_enabled_ = scl_pullup_enabled; }
   void set_frequency(uint32_t frequency) { frequency_ = frequency; }
+  void set_timeout(uint32_t timeout) { timeout_ = timeout; }
 
  private:
   void recover_();
@@ -41,6 +42,7 @@ class IDFI2CBus : public I2CBus, public Component {
   uint8_t scl_pin_;
   bool scl_pullup_enabled_;
   uint32_t frequency_;
+  uint32_t timeout_ = 0;
   bool initialized_ = false;
 };
 

esphome/components/internal_temperature/internal_temperature.cpp

@@ -14,6 +14,11 @@ uint8_t temprature_sens_read();
 #ifdef USE_RP2040
 #include "Arduino.h"
 #endif  // USE_RP2040
+#ifdef USE_BK72XX
+extern "C" {
+uint32_t temp_single_get_current_temperature(uint32_t *temp_value);
+}
+#endif  // USE_BK72XX
 
 namespace esphome {
 namespace internal_temperature {
@@ -46,6 +51,16 @@ void InternalTemperatureSensor::update() {
   temperature = analogReadTemp();
   success = (temperature != 0.0f);
 #endif  // USE_RP2040
+#ifdef USE_BK72XX
+  uint32_t raw, result;
+  result = temp_single_get_current_temperature(&raw);
+  success = (result == 0);
+#ifdef USE_LIBRETINY_VARIANT_BK7231T
+  temperature = raw * 0.04f;
+#else
+  temperature = raw * 0.128f;
+#endif  // USE_LIBRETINY_VARIANT_BK7231T
+#endif  // USE_BK72XX
   if (success && std::isfinite(temperature)) {
     this->publish_state(temperature);
   } else {

esphome/components/internal_temperature/sensor.py

@@ -14,6 +14,7 @@ from esphome.const import (
     KEY_FRAMEWORK_VERSION,
     PLATFORM_ESP32,
     PLATFORM_RP2040,
+    PLATFORM_BK72XX,
 )
 from esphome.core import CORE
 
@@ -51,7 +52,7 @@ CONFIG_SCHEMA = cv.All(
         state_class=STATE_CLASS_MEASUREMENT,
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
     ).extend(cv.polling_component_schema("60s")),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_RP2040]),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_RP2040, PLATFORM_BK72XX]),
     validate_config,
 )
 

esphome/components/libretiny/__init__.py

@@ -170,7 +170,7 @@ def _notify_old_style(config):
 ARDUINO_VERSIONS = {
     "dev": (cv.Version(0, 0, 0), "https://github.com/libretiny-eu/libretiny.git"),
     "latest": (cv.Version(0, 0, 0), None),
-    "recommended": (cv.Version(1, 4, 1), None),
+    "recommended": (cv.Version(1, 5, 1), None),
 }
 
 

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:
-        cg.add(
-            light_var.set_default_transition_length(
-                config[CONF_DEFAULT_TRANSITION_LENGTH]
-            )
-        )
-    if CONF_FLASH_TRANSITION_LENGTH in config:
-        cg.add(
-            light_var.set_flash_transition_length(config[CONF_FLASH_TRANSITION_LENGTH])
-        )
-    if CONF_GAMMA_CORRECT in config:
-        cg.add(light_var.set_gamma_correct(config[CONF_GAMMA_CORRECT]))
+    if (
+        default_transition_length := config.get(CONF_DEFAULT_TRANSITION_LENGTH)
+    ) is not None:
+        cg.add(light_var.set_default_transition_length(default_transition_length))
+    if (
+        flash_transition_length := config.get(CONF_FLASH_TRANSITION_LENGTH)
+    ) is not None:
+        cg.add(light_var.set_flash_transition_length(flash_transition_length))
+    if (gamma_correct := config.get(CONF_GAMMA_CORRECT)) is not None:
+        cg.add(light_var.set_gamma_correct(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:
-        cg.add(output_var.set_correction(*config[CONF_COLOR_CORRECT]))
+    if (color_correct := config.get(CONF_COLOR_CORRECT)) is not None:
+        cg.add(output_var.set_correction(*color_correct))
 
-    if CONF_POWER_SUPPLY in config:
-        var_ = await cg.get_variable(config[CONF_POWER_SUPPLY])
+    if (power_supply_id := config.get(CONF_POWER_SUPPLY)) is not None:
+        var_ = await cg.get_variable(power_supply_id)
         cg.add(output_var.set_power_supply(var_))
 
-    if CONF_MQTT_ID in config:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], light_var)
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
+        mqtt_ = cg.new_Pvariable(mqtt_id, light_var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
 

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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    if mqtt_id := config.get(CONF_MQTT_ID):
+        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/microphone/automation.h

@@ -23,7 +23,7 @@ class DataTrigger : public Trigger<const std::vector<int16_t> &> {
   }
 };
 
-template<typename... Ts> class IsCapturingActon : public Condition<Ts...>, public Parented<Microphone> {
+template<typename... Ts> class IsCapturingCondition : public Condition<Ts...>, public Parented<Microphone> {
  public:
   bool check(Ts... x) override { return this->parent_->is_running(); }
 };

esphome/components/mqtt/__init__.py

@@ -113,7 +113,8 @@ MQTTSensorComponent = mqtt_ns.class_("MQTTSensorComponent", MQTTComponent)
 MQTTSwitchComponent = mqtt_ns.class_("MQTTSwitchComponent", MQTTComponent)
 MQTTTextSensor = mqtt_ns.class_("MQTTTextSensor", MQTTComponent)
 MQTTNumberComponent = mqtt_ns.class_("MQTTNumberComponent", MQTTComponent)
-MQTTDatetimeComponent = mqtt_ns.class_("MQTTDatetimeComponent", MQTTComponent)
+MQTTDateComponent = mqtt_ns.class_("MQTTDateComponent", MQTTComponent)
+MQTTTimeComponent = mqtt_ns.class_("MQTTTimeComponent", MQTTComponent)
 MQTTTextComponent = mqtt_ns.class_("MQTTTextComponent", MQTTComponent)
 MQTTSelectComponent = mqtt_ns.class_("MQTTSelectComponent", MQTTComponent)
 MQTTButtonComponent = mqtt_ns.class_("MQTTButtonComponent", MQTTComponent)

esphome/components/mqtt/mqtt_date.h

@@ -13,9 +13,9 @@ namespace mqtt {
 
 class MQTTDateComponent : public mqtt::MQTTComponent {
  public:
-  /** Construct this MQTTDatetimeComponent instance with the provided friendly_name and datetime
+  /** Construct this MQTTDateComponent instance with the provided friendly_name and date
    *
-   * @param datetime The datetime component.
+   * @param date The date component.
    */
   explicit MQTTDateComponent(datetime::DateEntity *date);
 

esphome/components/mqtt/mqtt_time.cpp

@@ -0,0 +1,68 @@
+#include "mqtt_time.h"
+
+#include <utility>
+#include "esphome/core/log.h"
+
+#include "mqtt_const.h"
+
+#ifdef USE_MQTT
+#ifdef USE_DATETIME_TIME
+
+namespace esphome {
+namespace mqtt {
+
+static const char *const TAG = "mqtt.datetime.time";
+
+using namespace esphome::datetime;
+
+MQTTTimeComponent::MQTTTimeComponent(TimeEntity *time) : time_(time) {}
+
+void MQTTTimeComponent::setup() {
+  this->subscribe_json(this->get_command_topic_(), [this](const std::string &topic, JsonObject root) {
+    auto call = this->time_->make_call();
+    if (root.containsKey("hour")) {
+      call.set_hour(root["hour"]);
+    }
+    if (root.containsKey("minute")) {
+      call.set_minute(root["minute"]);
+    }
+    if (root.containsKey("second")) {
+      call.set_second(root["second"]);
+    }
+    call.perform();
+  });
+  this->time_->add_on_state_callback(
+      [this]() { this->publish_state(this->time_->hour, this->time_->minute, this->time_->second); });
+}
+
+void MQTTTimeComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "MQTT Time '%s':", this->time_->get_name().c_str());
+  LOG_MQTT_COMPONENT(true, true)
+}
+
+std::string MQTTTimeComponent::component_type() const { return "time"; }
+const EntityBase *MQTTTimeComponent::get_entity() const { return this->time_; }
+
+void MQTTTimeComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
+  // Nothing extra to add here
+}
+bool MQTTTimeComponent::send_initial_state() {
+  if (this->time_->has_state()) {
+    return this->publish_state(this->time_->hour, this->time_->minute, this->time_->second);
+  } else {
+    return true;
+  }
+}
+bool MQTTTimeComponent::publish_state(uint8_t hour, uint8_t minute, uint8_t second) {
+  return this->publish_json(this->get_state_topic_(), [hour, minute, second](JsonObject root) {
+    root["hour"] = hour;
+    root["minute"] = minute;
+    root["second"] = second;
+  });
+}
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif  // USE_DATETIME_TIME
+#endif  // USE_MQTT

esphome/components/mqtt/mqtt_time.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_MQTT
+#ifdef USE_DATETIME_TIME
+
+#include "esphome/components/datetime/time_entity.h"
+#include "mqtt_component.h"
+
+namespace esphome {
+namespace mqtt {
+
+class MQTTTimeComponent : public mqtt::MQTTComponent {
+ public:
+  /** Construct this MQTTTimeComponent instance with the provided friendly_name and time
+   *
+   * @param time The time entity.
+   */
+  explicit MQTTTimeComponent(datetime::TimeEntity *time);
+
+  // ========== INTERNAL METHODS ==========
+  // (In most use cases you won't need these)
+  /// Override setup.
+  void setup() override;
+  void dump_config() override;
+
+  void send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) override;
+
+  bool send_initial_state() override;
+
+  bool publish_state(uint8_t hour, uint8_t minute, uint8_t second);
+
+ protected:
+  std::string component_type() const override;
+  const EntityBase *get_entity() const override;
+
+  datetime::TimeEntity *time_;
+};
+
+}  // namespace mqtt
+}  // namespace esphome
+
+#endif  // USE_DATETIME_DATE
+#endif  // USE_MQTT

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:
-        cg.add(var.traits.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
-    if CONF_MQTT_ID in config:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    if (unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)) is not None:
+        cg.add(var.traits.set_unit_of_measurement(unit_of_measurement))
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        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:
-        cg.add(var.set_min(config[CONF_ABOVE]))
-    if CONF_BELOW in config:
-        cg.add(var.set_max(config[CONF_BELOW]))
+    if (above := config.get(CONF_ABOVE)) is not None:
+        cg.add(var.set_min(above))
+    if (below := config.get(CONF_BELOW)) is not None:
+        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:
-        to_ = await cg.templatable(config[CONF_OPERATION], args, NumberOperation)
+    if (operation := config.get(CONF_OPERATION)) is not None:
+        to_ = await cg.templatable(operation, args, NumberOperation)
         cg.add(var.set_operation(to_))
-        if CONF_CYCLE in config:
-            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
-            cg.add(var.set_cycle(cycle_))
-    if CONF_MODE in config:
-        cg.add(var.set_operation(NUMBER_OPERATION_OPTIONS[config[CONF_MODE]]))
-        if CONF_CYCLE in config:
-            cg.add(var.set_cycle(config[CONF_CYCLE]))
+        if (cycle := config.get(CONF_CYCLE)) is not None:
+            template_ = await cg.templatable(cycle, args, bool)
+            cg.add(var.set_cycle(template_))
+    if (mode := config.get(CONF_MODE)) is not None:
+        cg.add(var.set_operation(NUMBER_OPERATION_OPTIONS[mode]))
+        if (cycle := config.get(CONF_CYCLE)) is not None:
+            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})
@@ -1718,3 +1772,105 @@ async def haier_action(var, config, args):
     vec_ = cg.std_vector.template(cg.uint8)
     template_ = await cg.templatable(config[CONF_CODE], args, vec_, vec_)
     cg.add(var.set_code(template_))
+
+
+# ABBWelcome
+(
+    ABBWelcomeData,
+    ABBWelcomeBinarySensor,
+    ABBWelcomeTrigger,
+    ABBWelcomeAction,
+    ABBWelcomeDumper,
+) = declare_protocol("ABBWelcome")
+
+CONF_SOURCE_ADDRESS = "source_address"
+CONF_DESTINATION_ADDRESS = "destination_address"
+CONF_THREE_BYTE_ADDRESS = "three_byte_address"
+CONF_MESSAGE_TYPE = "message_type"
+CONF_MESSAGE_ID = "message_id"
+CONF_RETRANSMISSION = "retransmission"
+
+ABB_WELCOME_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_SOURCE_ADDRESS): cv.hex_uint32_t,
+        cv.Required(CONF_DESTINATION_ADDRESS): cv.hex_uint32_t,
+        cv.Optional(CONF_RETRANSMISSION, default=False): cv.boolean,
+        cv.Optional(CONF_THREE_BYTE_ADDRESS, default=False): cv.boolean,
+        cv.Required(CONF_MESSAGE_TYPE): cv.Any(cv.hex_uint8_t, cv.uint8_t),
+        cv.Optional(CONF_MESSAGE_ID): cv.Any(cv.hex_uint8_t, cv.uint8_t),
+        cv.Optional(CONF_DATA): cv.All(
+            [cv.Any(cv.hex_uint8_t, cv.uint8_t)],
+            cv.Length(min=0, max=7),
+        ),
+    }
+)
+
+
+@register_binary_sensor("abbwelcome", ABBWelcomeBinarySensor, ABB_WELCOME_SCHEMA)
+def abbwelcome_binary_sensor(var, config):
+    cg.add(var.set_three_byte_address(config[CONF_THREE_BYTE_ADDRESS]))
+    cg.add(var.set_source_address(config[CONF_SOURCE_ADDRESS]))
+    cg.add(var.set_destination_address(config[CONF_DESTINATION_ADDRESS]))
+    cg.add(var.set_retransmission(config[CONF_RETRANSMISSION]))
+    cg.add(var.set_message_type(config[CONF_MESSAGE_TYPE]))
+    cg.add(var.set_auto_message_id(CONF_MESSAGE_ID not in config))
+    if CONF_MESSAGE_ID in config:
+        cg.add(var.set_message_id(config[CONF_MESSAGE_ID]))
+    if CONF_DATA in config:
+        cg.add(var.set_data(config[CONF_DATA]))
+    cg.add(var.finalize())
+
+
+@register_trigger("abbwelcome", ABBWelcomeTrigger, ABBWelcomeData)
+def abbwelcome_trigger(var, config):
+    pass
+
+
+@register_dumper("abbwelcome", ABBWelcomeDumper)
+def abbwelcome_dumper(var, config):
+    pass
+
+
+@register_action("abbwelcome", ABBWelcomeAction, ABB_WELCOME_SCHEMA)
+async def abbwelcome_action(var, config, args):
+    cg.add(
+        var.set_three_byte_address(
+            await cg.templatable(config[CONF_THREE_BYTE_ADDRESS], args, cg.bool_)
+        )
+    )
+    cg.add(
+        var.set_source_address(
+            await cg.templatable(config[CONF_SOURCE_ADDRESS], args, cg.uint16)
+        )
+    )
+    cg.add(
+        var.set_destination_address(
+            await cg.templatable(config[CONF_DESTINATION_ADDRESS], args, cg.uint16)
+        )
+    )
+    cg.add(
+        var.set_retransmission(
+            await cg.templatable(config[CONF_RETRANSMISSION], args, cg.bool_)
+        )
+    )
+    cg.add(
+        var.set_message_type(
+            await cg.templatable(config[CONF_MESSAGE_TYPE], args, cg.uint8)
+        )
+    )
+    cg.add(var.set_auto_message_id(CONF_MESSAGE_ID not in config))
+    if CONF_MESSAGE_ID in config:
+        cg.add(
+            var.set_message_id(
+                await cg.templatable(config[CONF_MESSAGE_ID], args, cg.uint8)
+            )
+        )
+    if CONF_DATA in config:
+        data_ = config[CONF_DATA]
+        if cg.is_template(data_):
+            template_ = await cg.templatable(
+                data_, args, cg.std_vector.template(cg.uint8)
+            )
+            cg.add(var.set_data_template(template_))
+        else:
+            cg.add(var.set_data_static(data_))

esphome/components/remote_base/abbwelcome_protocol.cpp

@@ -0,0 +1,123 @@
+#include "abbwelcome_protocol.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace remote_base {
+
+static const char *const TAG = "remote.abbwelcome";
+
+static const uint32_t BIT_ONE_SPACE_US = 102;
+static const uint32_t BIT_ZERO_MARK_US = 32;  // 18-44
+static const uint32_t BIT_ZERO_SPACE_US = BIT_ONE_SPACE_US - BIT_ZERO_MARK_US;
+static const uint16_t BYTE_SPACE_US = 210;
+
+uint8_t ABBWelcomeData::calc_cs_() const {
+  uint8_t checksum = 0;
+  for (uint8_t i = 0; i < this->size() - 1; i++) {
+    uint16_t temp = checksum ^ (this->data_[i]);
+    temp = temp ^ (uint16_t) (((uint32_t) temp << 0x11) >> 0x10) ^ (uint16_t) (((uint32_t) temp << 0x12) >> 0x10) ^
+           (uint16_t) (((uint32_t) temp << 0x13) >> 0x10) ^ (uint16_t) (((uint32_t) temp << 0x14) >> 0x10) ^
+           (uint16_t) (((uint32_t) temp << 0x15) >> 0x10) ^ (uint16_t) (((uint32_t) temp << 0x16) >> 0x10) ^
+           (uint16_t) (((uint32_t) temp << 0x17) >> 0x10);
+    checksum = (temp & 0xfe) ^ ((temp >> 8) & 1);
+  }
+  return ~checksum;
+}
+
+void ABBWelcomeProtocol::encode_byte_(RemoteTransmitData *dst, uint8_t data) const {
+  // space = bus high, mark = activate bus pulldown
+  dst->mark(BIT_ZERO_MARK_US);
+  uint32_t next_space = BIT_ZERO_SPACE_US;
+  for (uint8_t mask = 1 << 7; mask; mask >>= 1) {
+    if (data & mask) {
+      next_space += BIT_ONE_SPACE_US;
+    } else {
+      dst->space(next_space);
+      dst->mark(BIT_ZERO_MARK_US);
+      next_space = BIT_ZERO_SPACE_US;
+    }
+  }
+  next_space += BYTE_SPACE_US;
+  dst->space(next_space);
+}
+
+void ABBWelcomeProtocol::encode(RemoteTransmitData *dst, const ABBWelcomeData &src) {
+  dst->set_carrier_frequency(0);
+  uint32_t reserve_count = 0;
+  for (size_t i = 0; i < src.size(); i++) {
+    reserve_count += 2 * (9 - (src[i] & 1) - ((src[i] >> 1) & 1) - ((src[i] >> 2) & 1) - ((src[i] >> 3) & 1) -
+                          ((src[i] >> 4) & 1) - ((src[i] >> 5) & 1) - ((src[i] >> 6) & 1) - ((src[i] >> 7) & 1));
+  }
+  dst->reserve(reserve_count);
+  for (size_t i = 0; i < src.size(); i++)
+    this->encode_byte_(dst, src[i]);
+  ESP_LOGD(TAG, "Transmitting: %s", src.to_string().c_str());
+}
+
+bool ABBWelcomeProtocol::decode_byte_(RemoteReceiveData &src, bool &done, uint8_t &data) {
+  if (!src.expect_mark(BIT_ZERO_MARK_US))
+    return false;
+  uint32_t next_space = BIT_ZERO_SPACE_US;
+  for (uint8_t mask = 1 << 7; mask; mask >>= 1) {
+    // if (!src.peek_space_at_least(next_space, 0))
+    //   return false;
+    if (src.expect_space(next_space)) {
+      if (!src.expect_mark(BIT_ZERO_MARK_US))
+        return false;
+      next_space = BIT_ZERO_SPACE_US;
+    } else {
+      data |= mask;
+      next_space += BIT_ONE_SPACE_US;
+    }
+  }
+  next_space += BYTE_SPACE_US;
+  // if (!src.peek_space_at_least(next_space, 0))
+  //   return false;
+  done = !(src.expect_space(next_space));
+  return true;
+}
+
+optional<ABBWelcomeData> ABBWelcomeProtocol::decode(RemoteReceiveData src) {
+  if (src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US) &&
+      src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US + BIT_ONE_SPACE_US) &&
+      src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US + BIT_ONE_SPACE_US) &&
+      src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US + BIT_ONE_SPACE_US) &&
+      src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US + BIT_ONE_SPACE_US + BYTE_SPACE_US) &&
+      src.expect_item(BIT_ZERO_MARK_US, BIT_ZERO_SPACE_US + 8 * BIT_ONE_SPACE_US + BYTE_SPACE_US)) {
+    ESP_LOGVV(TAG, "Received Header: 0x55FF");
+    ABBWelcomeData out;
+    out[0] = 0x55;
+    out[1] = 0xff;
+    bool done = false;
+    uint8_t length = 10;
+    uint8_t received_bytes = 2;
+    for (; (received_bytes < length) && !done; received_bytes++) {
+      uint8_t data = 0;
+      if (!this->decode_byte_(src, done, data)) {
+        ESP_LOGW(TAG, "Received incomplete packet: %s", out.to_string(received_bytes).c_str());
+        return {};
+      }
+      if (received_bytes == 2) {
+        length += std::min(static_cast<uint8_t>(data & DATA_LENGTH_MASK), MAX_DATA_LENGTH);
+        if (data & 0x40) {
+          length += 2;
+        }
+      }
+      ESP_LOGVV(TAG, "Received Byte: 0x%02X", data);
+      out[received_bytes] = data;
+    }
+    if (out.is_valid()) {
+      ESP_LOGI(TAG, "Received: %s", out.to_string().c_str());
+      return out;
+    }
+    ESP_LOGW(TAG, "Received malformed packet: %s", out.to_string(received_bytes).c_str());
+  }
+  return {};
+}
+
+void ABBWelcomeProtocol::dump(const ABBWelcomeData &data) {
+  ESP_LOGD(TAG, "Received ABBWelcome: %s", data.to_string().c_str());
+}
+
+}  // namespace remote_base
+}  // namespace esphome

esphome/components/remote_base/abbwelcome_protocol.h

@@ -0,0 +1,251 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "remote_base.h"
+#include <array>
+#include <utility>
+#include <vector>
+
+namespace esphome {
+namespace remote_base {
+
+static const uint8_t MAX_DATA_LENGTH = 15;
+static const uint8_t DATA_LENGTH_MASK = 0x3f;
+
+/*
+Message Format:
+  2 bytes:   Sync (0x55FF)
+  1 bit:     Retransmission flag (High means retransmission)
+  1 bit:     Address length flag (Low means 2 bytes, High means 3 bytes)
+  2 bits:    Unknown
+  4 bits:    Data length (in bytes)
+  1 bit:     Reply flag (High means this is a reply to a previous message with the same message type)
+  7 bits:    Message type
+  2-3 bytes: Destination address
+  2-3 bytes: Source address
+  1 byte:    Message ID (randomized, does not change for retransmissions)
+  0-? bytes: Data
+  1 byte:    Checksum
+*/
+
+class ABBWelcomeData {
+ public:
+  // Make default
+  ABBWelcomeData() {
+    std::fill(std::begin(this->data_), std::end(this->data_), 0);
+    this->data_[0] = 0x55;
+    this->data_[1] = 0xff;
+  }
+  // Make from initializer_list
+  ABBWelcomeData(std::initializer_list<uint8_t> data) {
+    std::fill(std::begin(this->data_), std::end(this->data_), 0);
+    std::copy_n(data.begin(), std::min(data.size(), this->data_.size()), this->data_.begin());
+  }
+  // Make from vector
+  ABBWelcomeData(const std::vector<uint8_t> &data) {
+    std::fill(std::begin(this->data_), std::end(this->data_), 0);
+    std::copy_n(data.begin(), std::min(data.size(), this->data_.size()), this->data_.begin());
+  }
+  // Default copy constructor
+  ABBWelcomeData(const ABBWelcomeData &) = default;
+
+  bool auto_message_id{false};
+
+  uint8_t *data() { return this->data_.data(); }
+  const uint8_t *data() const { return this->data_.data(); }
+  uint8_t size() const {
+    return std::min(static_cast<uint8_t>(6 + (2 * this->get_address_length()) + (this->data_[2] & DATA_LENGTH_MASK)),
+                    static_cast<uint8_t>(this->data_.size()));
+  }
+  bool is_valid() const {
+    return this->data_[0] == 0x55 && this->data_[1] == 0xff &&
+           ((this->data_[2] & DATA_LENGTH_MASK) <= MAX_DATA_LENGTH) &&
+           (this->data_[this->size() - 1] == this->calc_cs_());
+  }
+  void set_retransmission(bool retransmission) {
+    if (retransmission) {
+      this->data_[2] |= 0x80;
+    } else {
+      this->data_[2] &= 0x7f;
+    }
+  }
+  bool get_retransmission() const { return this->data_[2] & 0x80; }
+  // set_three_byte_address must be called before set_source_address, set_destination_address, set_message_id and
+  // set_data!
+  void set_three_byte_address(bool three_byte_address) {
+    if (three_byte_address) {
+      this->data_[2] |= 0x40;
+    } else {
+      this->data_[2] &= 0xbf;
+    }
+  }
+  uint8_t get_three_byte_address() const { return (this->data_[2] & 0x40); }
+  uint8_t get_address_length() const { return this->get_three_byte_address() ? 3 : 2; }
+  void set_message_type(uint8_t message_type) { this->data_[3] = message_type; }
+  uint8_t get_message_type() const { return this->data_[3]; }
+  void set_destination_address(uint32_t address) {
+    if (this->get_address_length() == 2) {
+      this->data_[4] = (address >> 8) & 0xff;
+      this->data_[5] = address & 0xff;
+    } else {
+      this->data_[4] = (address >> 16) & 0xff;
+      this->data_[5] = (address >> 8) & 0xff;
+      this->data_[6] = address & 0xff;
+    }
+  }
+  uint32_t get_destination_address() const {
+    if (this->get_address_length() == 2) {
+      return (this->data_[4] << 8) + this->data_[5];
+    }
+    return (this->data_[4] << 16) + (this->data_[5] << 8) + this->data_[6];
+  }
+  void set_source_address(uint32_t address) {
+    if (this->get_address_length() == 2) {
+      this->data_[6] = (address >> 8) & 0xff;
+      this->data_[7] = address & 0xff;
+    } else {
+      this->data_[7] = (address >> 16) & 0xff;
+      this->data_[8] = (address >> 8) & 0xff;
+      this->data_[9] = address & 0xff;
+    }
+  }
+  uint32_t get_source_address() const {
+    if (this->get_address_length() == 2) {
+      return (this->data_[6] << 8) + this->data_[7];
+    }
+    return (this->data_[7] << 16) + (this->data_[8] << 8) + this->data_[9];
+  }
+  void set_message_id(uint8_t message_id) { this->data_[4 + 2 * this->get_address_length()] = message_id; }
+  uint8_t get_message_id() const { return this->data_[4 + 2 * this->get_address_length()]; }
+  void set_data(std::vector<uint8_t> data) {
+    uint8_t size = std::min(MAX_DATA_LENGTH, static_cast<uint8_t>(data.size()));
+    this->data_[2] &= (0xff ^ DATA_LENGTH_MASK);
+    this->data_[2] |= (size & DATA_LENGTH_MASK);
+    if (size)
+      std::copy_n(data.begin(), size, this->data_.begin() + 5 + 2 * this->get_address_length());
+  }
+  std::vector<uint8_t> get_data() const {
+    std::vector<uint8_t> data(this->data_.begin() + 5 + 2 * this->get_address_length(),
+                              this->data_.begin() + 5 + 2 * this->get_address_length() + this->get_data_size());
+    return data;
+  }
+  uint8_t get_data_size() const {
+    return std::min(MAX_DATA_LENGTH, static_cast<uint8_t>(this->data_[2] & DATA_LENGTH_MASK));
+  }
+  void finalize() {
+    if (this->auto_message_id && !this->get_retransmission() && !(this->data_[3] & 0x80)) {
+      this->set_message_id(static_cast<uint8_t>(random_uint32()));
+    }
+    this->data_[0] = 0x55;
+    this->data_[1] = 0xff;
+    this->data_[this->size() - 1] = this->calc_cs_();
+  }
+  std::string to_string(uint8_t max_print_bytes = 255) const {
+    std::string info;
+    if (this->is_valid()) {
+      info = str_sprintf(this->get_three_byte_address() ? "[%06X %s %06X] Type: %02X" : "[%04X %s %04X] Type: %02X",
+                         this->get_source_address(), this->get_retransmission() ? "»" : ">",
+                         this->get_destination_address(), this->get_message_type());
+      if (this->get_data_size())
+        info += str_sprintf(", Data: %s", format_hex_pretty(this->get_data()).c_str());
+    } else {
+      info = "[Invalid]";
+    }
+    uint8_t print_bytes = std::min(this->size(), max_print_bytes);
+    if (print_bytes)
+      info = str_sprintf("%s %s", format_hex_pretty(this->data_.data(), print_bytes).c_str(), info.c_str());
+    return info;
+  }
+  bool operator==(const ABBWelcomeData &rhs) const {
+    if (std::equal(this->data_.begin(), this->data_.begin() + this->size(), rhs.data_.begin()))
+      return true;
+    return (this->auto_message_id || rhs.auto_message_id) && this->is_valid() && rhs.is_valid() &&
+           (this->get_message_type() == rhs.get_message_type()) &&
+           (this->get_source_address() == rhs.get_source_address()) &&
+           (this->get_destination_address() == rhs.get_destination_address()) && (this->get_data() == rhs.get_data());
+  }
+  uint8_t &operator[](size_t idx) { return this->data_[idx]; }
+  const uint8_t &operator[](size_t idx) const { return this->data_[idx]; }
+
+ protected:
+  std::array<uint8_t, 12 + MAX_DATA_LENGTH> data_;
+  // Calculate checksum
+  uint8_t calc_cs_() const;
+};
+
+class ABBWelcomeProtocol : public RemoteProtocol<ABBWelcomeData> {
+ public:
+  void encode(RemoteTransmitData *dst, const ABBWelcomeData &src) override;
+  optional<ABBWelcomeData> decode(RemoteReceiveData src) override;
+  void dump(const ABBWelcomeData &data) override;
+
+ protected:
+  void encode_byte_(RemoteTransmitData *dst, uint8_t data) const;
+  bool decode_byte_(RemoteReceiveData &src, bool &done, uint8_t &data);
+};
+
+class ABBWelcomeBinarySensor : public RemoteReceiverBinarySensorBase {
+ public:
+  bool matches(RemoteReceiveData src) override {
+    auto data = ABBWelcomeProtocol().decode(src);
+    return data.has_value() && data.value() == this->data_;
+  }
+  void set_source_address(const uint32_t source_address) { this->data_.set_source_address(source_address); }
+  void set_destination_address(const uint32_t destination_address) {
+    this->data_.set_destination_address(destination_address);
+  }
+  void set_retransmission(const bool retransmission) { this->data_.set_retransmission(retransmission); }
+  void set_three_byte_address(const bool three_byte_address) { this->data_.set_three_byte_address(three_byte_address); }
+  void set_message_type(const uint8_t message_type) { this->data_.set_message_type(message_type); }
+  void set_message_id(const uint8_t message_id) { this->data_.set_message_id(message_id); }
+  void set_auto_message_id(const bool auto_message_id) { this->data_.auto_message_id = auto_message_id; }
+  void set_data(const std::vector<uint8_t> &data) { this->data_.set_data(data); }
+  void finalize() { this->data_.finalize(); }
+
+ protected:
+  ABBWelcomeData data_;
+};
+
+using ABBWelcomeTrigger = RemoteReceiverTrigger<ABBWelcomeProtocol>;
+using ABBWelcomeDumper = RemoteReceiverDumper<ABBWelcomeProtocol>;
+
+template<typename... Ts> class ABBWelcomeAction : public RemoteTransmitterActionBase<Ts...> {
+  TEMPLATABLE_VALUE(uint32_t, source_address)
+  TEMPLATABLE_VALUE(uint32_t, destination_address)
+  TEMPLATABLE_VALUE(bool, retransmission)
+  TEMPLATABLE_VALUE(bool, three_byte_address)
+  TEMPLATABLE_VALUE(uint8_t, message_type)
+  TEMPLATABLE_VALUE(uint8_t, message_id)
+  TEMPLATABLE_VALUE(bool, auto_message_id)
+  void set_data_static(std::vector<uint8_t> data) { data_static_ = std::move(data); }
+  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    has_data_func_ = true;
+  }
+  void encode(RemoteTransmitData *dst, Ts... x) override {
+    ABBWelcomeData data;
+    data.set_three_byte_address(this->three_byte_address_.value(x...));
+    data.set_source_address(this->source_address_.value(x...));
+    data.set_destination_address(this->destination_address_.value(x...));
+    data.set_retransmission(this->retransmission_.value(x...));
+    data.set_message_type(this->message_type_.value(x...));
+    data.set_message_id(this->message_id_.value(x...));
+    data.auto_message_id = this->auto_message_id_.value(x...);
+    if (has_data_func_) {
+      data.set_data(this->data_func_(x...));
+    } else {
+      data.set_data(this->data_static_);
+    }
+    data.finalize();
+    ABBWelcomeProtocol().encode(dst, data);
+  }
+
+ protected:
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
+  bool has_data_func_{false};
+};
+
+}  // namespace remote_base
+}  // namespace esphome

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/remote_base.cpp

@@ -15,6 +15,9 @@ RemoteRMTChannel::RemoteRMTChannel(uint8_t mem_block_num) : mem_block_num_(mem_b
   next_rmt_channel = rmt_channel_t(int(next_rmt_channel) + mem_block_num);
 }
 
+RemoteRMTChannel::RemoteRMTChannel(rmt_channel_t channel, uint8_t mem_block_num)
+    : channel_(channel), mem_block_num_(mem_block_num) {}
+
 void RemoteRMTChannel::config_rmt(rmt_config_t &rmt) {
   if (rmt_channel_t(int(this->channel_) + this->mem_block_num_) > RMT_CHANNEL_MAX) {
     this->mem_block_num_ = int(RMT_CHANNEL_MAX) - int(this->channel_);

esphome/components/remote_base/remote_base.h

@@ -3,10 +3,10 @@
 
 #pragma once
 
+#include "esphome/components/binary_sensor/binary_sensor.h"
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/automation.h"
-#include "esphome/components/binary_sensor/binary_sensor.h"
 
 #ifdef USE_ESP32
 #include <driver/rmt.h>
@@ -86,6 +86,7 @@ class RemoteComponentBase {
 class RemoteRMTChannel {
  public:
   explicit RemoteRMTChannel(uint8_t mem_block_num = 1);
+  explicit RemoteRMTChannel(rmt_channel_t channel, uint8_t mem_block_num = 1);
 
   void config_rmt(rmt_config_t &rmt);
   void set_clock_divider(uint8_t clock_divider) { this->clock_divider_ = clock_divider; }

esphome/components/remote_receiver/__init__.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.components import remote_base
+from esphome.components import remote_base, esp32_rmt
 from esphome.const import (
     CONF_BUFFER_SIZE,
     CONF_DUMP,
@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_PIN,
     CONF_TOLERANCE,
     CONF_MEMORY_BLOCKS,
+    CONF_RMT_CHANNEL,
 )
 from esphome.core import CORE, TimePeriod
 
@@ -45,6 +46,7 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
                 CONF_IDLE, default="10ms"
             ): cv.positive_time_period_microseconds,
             cv.Optional(CONF_MEMORY_BLOCKS, default=3): cv.Range(min=1, max=8),
+            cv.Optional(CONF_RMT_CHANNEL): esp32_rmt.validate_rmt_channel(tx=False),
         }
     ).extend(cv.COMPONENT_SCHEMA)
 )
@@ -53,7 +55,12 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
 async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     if CORE.is_esp32:
-        var = cg.new_Pvariable(config[CONF_ID], pin, config[CONF_MEMORY_BLOCKS])
+        if (rmt_channel := config.get(CONF_RMT_CHANNEL, None)) is not None:
+            var = cg.new_Pvariable(
+                config[CONF_ID], pin, rmt_channel, config[CONF_MEMORY_BLOCKS]
+            )
+        else:
+            var = cg.new_Pvariable(config[CONF_ID], pin, config[CONF_MEMORY_BLOCKS])
     else:
         var = cg.new_Pvariable(config[CONF_ID], pin)
 

esphome/components/remote_receiver/remote_receiver.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/components/remote_base/remote_base.h"
+#include "esphome/core/component.h"
 
 #include <cinttypes>
 
@@ -38,6 +38,9 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
 #ifdef USE_ESP32
   RemoteReceiverComponent(InternalGPIOPin *pin, uint8_t mem_block_num = 1)
       : RemoteReceiverBase(pin), remote_base::RemoteRMTChannel(mem_block_num) {}
+
+  RemoteReceiverComponent(InternalGPIOPin *pin, rmt_channel_t channel, uint8_t mem_block_num = 1)
+      : RemoteReceiverBase(pin), remote_base::RemoteRMTChannel(channel, mem_block_num) {}
 #else
   RemoteReceiverComponent(InternalGPIOPin *pin) : RemoteReceiverBase(pin) {}
 #endif

esphome/components/remote_transmitter/__init__.py

@@ -1,8 +1,8 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome import pins
-from esphome.components import remote_base
-from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN
+from esphome.components import remote_base, esp32_rmt
+from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN, CONF_RMT_CHANNEL
 
 AUTO_LOAD = ["remote_base"]
 remote_transmitter_ns = cg.esphome_ns.namespace("remote_transmitter")
@@ -18,13 +18,17 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Required(CONF_CARRIER_DUTY_PERCENT): cv.All(
             cv.percentage_int, cv.Range(min=1, max=100)
         ),
+        cv.Optional(CONF_RMT_CHANNEL): esp32_rmt.validate_rmt_channel(tx=True),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
 
 async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
-    var = cg.new_Pvariable(config[CONF_ID], pin)
+    if (rmt_channel := config.get(CONF_RMT_CHANNEL, None)) is not None:
+        var = cg.new_Pvariable(config[CONF_ID], pin, rmt_channel)
+    else:
+        var = cg.new_Pvariable(config[CONF_ID], pin)
     await cg.register_component(var, config)
 
     cg.add(var.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))

esphome/components/remote_transmitter/remote_transmitter.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/components/remote_base/remote_base.h"
+#include "esphome/core/component.h"
 
 #include <vector>
 
@@ -16,8 +16,15 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #endif
 {
  public:
-  explicit RemoteTransmitterComponent(InternalGPIOPin *pin) : remote_base::RemoteTransmitterBase(pin) {}
+#ifdef USE_ESP32
+  RemoteTransmitterComponent(InternalGPIOPin *pin, uint8_t mem_block_num = 1)
+      : remote_base::RemoteTransmitterBase(pin), remote_base::RemoteRMTChannel(mem_block_num) {}
 
+  RemoteTransmitterComponent(InternalGPIOPin *pin, rmt_channel_t channel, uint8_t mem_block_num = 1)
+      : remote_base::RemoteTransmitterBase(pin), remote_base::RemoteRMTChannel(channel, mem_block_num) {}
+#else
+  explicit RemoteTransmitterComponent(InternalGPIOPin *pin) : remote_base::RemoteTransmitterBase(pin) {}
+#endif
   void setup() override;
 
   void dump_config() override;

esphome/components/rtl87xx/boards.py

@@ -36,6 +36,10 @@ RTL87XX_BOARDS = {
         "name": "T103_V1.0",
         "family": FAMILY_RTL8710B,
     },
+    "t112-v1.1": {
+        "name": "T112_V1.1",
+        "family": FAMILY_RTL8710B,
+    },
     "wr1": {
         "name": "WR1 Wi-Fi Module",
         "family": FAMILY_RTL8710B,
@@ -125,7 +129,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -136,9 +139,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 22,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -180,11 +181,9 @@ RTL87XX_BOARD_PINS = {
         "SERIAL2_RTS": 20,
         "SERIAL2_RX": 15,
         "SERIAL2_TX": 16,
-        "CS0": 15,
         "CTS1": 4,
         "CTS2": 19,
         "MISO0": 20,
-        "MOSI0": 19,
         "PA00": 0,
         "PA0": 0,
         "PA01": 1,
@@ -203,23 +202,15 @@ RTL87XX_BOARD_PINS = {
         "PA18": 18,
         "PA19": 19,
         "PA20": 20,
-        "PWM0": 0,
         "PWM1": 1,
-        "PWM2": 14,
-        "PWM3": 3,
-        "PWM4": 16,
         "PWM5": 17,
         "PWM6": 18,
-        "PWM7": 13,
         "RTS2": 20,
         "RX0": 13,
-        "RX1": 0,
         "RX2": 15,
-        "SCK0": 3,
         "SCL0": 19,
         "SDA0": 3,
         "TX0": 14,
-        "TX1": 1,
         "TX2": 16,
         "D0": 17,
         "D1": 18,
@@ -294,7 +285,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -305,9 +295,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -390,7 +378,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -401,9 +388,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -485,7 +470,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -496,9 +480,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -560,7 +542,6 @@ RTL87XX_BOARD_PINS = {
         "CTS0": 10,
         "CTS1": 4,
         "CTS2": 19,
-        "MISO0": 20,
         "MOSI0": 19,
         "PA00": 0,
         "PA0": 0,
@@ -591,23 +572,13 @@ RTL87XX_BOARD_PINS = {
         "PA20": 20,
         "PA23": 23,
         "PWM0": 20,
-        "PWM1": 12,
-        "PWM2": 14,
-        "PWM3": 15,
-        "PWM4": 16,
         "PWM5": 17,
         "PWM6": 18,
         "PWM7": 23,
         "RTS0": 9,
         "RTS2": 20,
-        "RX0": 13,
-        "RX1": 2,
         "RX2": 15,
         "SCK0": 16,
-        "SCL0": 19,
-        "SDA0": 20,
-        "TX0": 14,
-        "TX1": 3,
         "TX2": 16,
         "D0": 0,
         "D1": 1,
@@ -652,7 +623,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 14,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -720,7 +690,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -731,9 +700,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -751,6 +718,75 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
+    "t112-v1.1": {
+        "SPI0_CS": 19,
+        "SPI0_MISO": 22,
+        "SPI0_MOSI": 23,
+        "SPI0_SCK": 18,
+        "SPI1_CS": 19,
+        "SPI1_MISO": 22,
+        "SPI1_MOSI": 23,
+        "SPI1_SCK": 18,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
+        "WIRE0_SDA_0": 19,
+        "WIRE0_SDA_1": 30,
+        "WIRE1_SCL": 18,
+        "WIRE1_SDA": 23,
+        "SERIAL0_CTS": 19,
+        "SERIAL0_RTS": 22,
+        "SERIAL0_RX": 18,
+        "SERIAL0_TX": 23,
+        "SERIAL2_RX": 29,
+        "SERIAL2_TX": 30,
+        "ADC1": 19,
+        "CS0": 19,
+        "CS1": 19,
+        "CTS0": 19,
+        "MISO0": 22,
+        "MISO1": 22,
+        "MOSI0": 23,
+        "MOSI1": 23,
+        "PA00": 0,
+        "PA0": 0,
+        "PA05": 5,
+        "PA5": 5,
+        "PA12": 12,
+        "PA14": 14,
+        "PA15": 15,
+        "PA18": 18,
+        "PA19": 19,
+        "PA22": 22,
+        "PA23": 23,
+        "PA29": 29,
+        "PA30": 30,
+        "PWM1": 15,
+        "PWM2": 0,
+        "PWM3": 12,
+        "PWM4": 30,
+        "PWM5": 22,
+        "RTS0": 22,
+        "RX0": 18,
+        "RX2": 29,
+        "SCK0": 18,
+        "SCK1": 18,
+        "SCL1": 18,
+        "SDA1": 23,
+        "TX0": 23,
+        "TX2": 30,
+        "D0": 29,
+        "D1": 19,
+        "D2": 15,
+        "D3": 14,
+        "D4": 0,
+        "D5": 5,
+        "D6": 18,
+        "D7": 12,
+        "D8": 23,
+        "D9": 22,
+        "D10": 30,
+        "A0": 19,
+    },
     "wr1": {
         "SPI0_CS": 19,
         "SPI0_MISO": 22,
@@ -793,7 +829,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 14,
         "PWM1": 15,
         "PWM2": 0,
         "PWM4": 29,
@@ -803,9 +838,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 22,
         "SCL1": 18,
-        "SDA0": 19,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -863,7 +896,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 14,
         "PWM1": 15,
         "PWM3": 12,
         "PWM4": 29,
@@ -873,9 +905,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 22,
         "SCL1": 18,
-        "SDA0": 19,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -915,7 +945,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 14,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -969,7 +998,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 14,
         "PWM1": 15,
         "PWM3": 12,
         "PWM4": 29,
@@ -979,7 +1007,6 @@ RTL87XX_BOARD_PINS = {
         "SCK1": 18,
         "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -1083,7 +1110,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -1094,9 +1120,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -1157,7 +1181,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -1168,9 +1191,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 22,
         "SCL1": 18,
-        "SDA0": 19,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -1231,7 +1252,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -1242,9 +1262,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 29,
         "SCL1": 18,
-        "SDA0": 30,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -1305,7 +1323,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,
@@ -1316,9 +1333,7 @@ RTL87XX_BOARD_PINS = {
         "RX2": 29,
         "SCK0": 18,
         "SCK1": 18,
-        "SCL0": 22,
         "SCL1": 18,
-        "SDA0": 19,
         "SDA1": 23,
         "TX0": 23,
         "TX2": 30,
@@ -1359,7 +1374,6 @@ RTL87XX_BOARD_PINS = {
         "PA23": 23,
         "PA29": 29,
         "PA30": 30,
-        "PWM0": 23,
         "PWM1": 15,
         "PWM2": 0,
         "PWM3": 12,

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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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)
 
 
@@ -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:
-        op_ = await cg.templatable(config[CONF_OPERATION], args, SelectOperation)
+    if (operation := config.get(CONF_OPERATION)) is not None:
+        op_ = await cg.templatable(operation, args, SelectOperation)
         cg.add(var.set_operation(op_))
-        if CONF_CYCLE in config:
-            cycle_ = await cg.templatable(config[CONF_CYCLE], args, bool)
-            cg.add(var.set_cycle(cycle_))
-    if CONF_MODE in config:
-        cg.add(var.set_operation(SELECT_OPERATION_OPTIONS[config[CONF_MODE]]))
-        if CONF_CYCLE in config:
-            cg.add(var.set_cycle(config[CONF_CYCLE]))
+        if (cycle := config.get(CONF_CYCLE)) is not None:
+            template_ = await cg.templatable(cycle, args, bool)
+            cg.add(var.set_cycle(template_))
+    if (mode := config.get(CONF_MODE)) is not None:
+        cg.add(var.set_operation(SELECT_OPERATION_OPTIONS[mode]))
+        if (cycle := config.get(CONF_CYCLE)) is not None:
+            cg.add(var.set_cycle(cycle))
     return var

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:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
-    if CONF_STATE_CLASS in config:
-        cg.add(var.set_state_class(config[CONF_STATE_CLASS]))
-    if CONF_UNIT_OF_MEASUREMENT in config:
-        cg.add(var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
-    if CONF_ACCURACY_DECIMALS in config:
-        cg.add(var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        cg.add(var.set_device_class(device_class))
+    if (state_class := config.get(CONF_STATE_CLASS)) is not None:
+        cg.add(var.set_state_class(state_class))
+    if (unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)) is not None:
+        cg.add(var.set_unit_of_measurement(unit_of_measurement))
+    if (accuracy_decimals := config.get(CONF_ACCURACY_DECIMALS)) is not None:
+        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:
-            template_ = await cg.templatable(conf[CONF_ABOVE], [(float, "x")], float)
+        if (above := conf.get(CONF_ABOVE)) is not None:
+            template_ = await cg.templatable(above, [(float, "x")], float)
             cg.add(trigger.set_min(template_))
-        if CONF_BELOW in conf:
-            template_ = await cg.templatable(conf[CONF_BELOW], [(float, "x")], float)
+        if (below := conf.get(CONF_BELOW)) is not None:
+            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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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_EXPIRE_AFTER in config:
-            if config[CONF_EXPIRE_AFTER] is None:
+        if (expire_after := config.get(CONF_EXPIRE_AFTER, _UNDEF)) is not _UNDEF:
+            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:
-        cg.add(var.set_min(config[CONF_ABOVE]))
-    if CONF_BELOW in config:
-        cg.add(var.set_max(config[CONF_BELOW]))
+    if (above := config.get(CONF_ABOVE)) is not None:
+        cg.add(var.set_min(above))
+    if (below := config.get(CONF_BELOW)) is not None:
+        cg.add(var.set_max(below))
 
     return var
 

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:
-        cg.add(var.set_inverted(config[CONF_INVERTED]))
+    if (inverted := config.get(CONF_INVERTED)) is not None:
+        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:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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.set_device_class(config[CONF_DEVICE_CLASS]))
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        cg.add(var.set_device_class(device_class))
 
     cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
 

esphome/components/template/datetime/__init__.py

@@ -8,6 +8,13 @@ from esphome.const import (
     CONF_OPTIMISTIC,
     CONF_RESTORE_VALUE,
     CONF_SET_ACTION,
+    CONF_DAY,
+    CONF_HOUR,
+    CONF_MINUTE,
+    CONF_MONTH,
+    CONF_SECOND,
+    CONF_TYPE,
+    CONF_YEAR,
 )
 
 from esphome.core import coroutine_with_priority
@@ -20,6 +27,10 @@ TemplateDate = template_ns.class_(
     "TemplateDate", datetime.DateEntity, cg.PollingComponent
 )
 
+TemplateTime = template_ns.class_(
+    "TemplateTime", datetime.TimeEntity, cg.PollingComponent
+)
+
 
 def validate(config):
     config = config.copy()
@@ -60,6 +71,13 @@ CONFIG_SCHEMA = cv.All(
                     cv.Optional(CONF_INITIAL_VALUE): cv.date_time(allowed_time=False),
                 }
             ),
+            "TIME": datetime.time_schema(TemplateTime)
+            .extend(_BASE_SCHEMA)
+            .extend(
+                {
+                    cv.Optional(CONF_INITIAL_VALUE): cv.date_time(allowed_date=False),
+                }
+            ),
         },
         upper=True,
     ),
@@ -82,7 +100,22 @@ async def to_code(config):
         cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
 
         if initial_value := config.get(CONF_INITIAL_VALUE):
-            cg.add(var.set_initial_value(initial_value))
+            if config[CONF_TYPE] == "DATE":
+                date_struct = cg.StructInitializer(
+                    cg.ESPTime,
+                    ("day_of_month", initial_value[CONF_DAY]),
+                    ("month", initial_value[CONF_MONTH]),
+                    ("year", initial_value[CONF_YEAR]),
+                )
+                cg.add(var.set_initial_value(date_struct))
+            elif config[CONF_TYPE] == "TIME":
+                time_struct = cg.StructInitializer(
+                    cg.ESPTime,
+                    ("second", initial_value[CONF_SECOND]),
+                    ("minute", initial_value[CONF_MINUTE]),
+                    ("hour", initial_value[CONF_HOUR]),
+                )
+                cg.add(var.set_initial_value(time_struct))
 
     if CONF_SET_ACTION in config:
         await automation.build_automation(

esphome/components/template/datetime/template_time.cpp

@@ -0,0 +1,111 @@
+#include "template_time.h"
+
+#ifdef USE_DATETIME_TIME
+
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace template_ {
+
+static const char *const TAG = "template.time";
+
+void TemplateTime::setup() {
+  if (this->f_.has_value())
+    return;
+
+  ESPTime state{};
+
+  if (!this->restore_value_) {
+    state = this->initial_value_;
+  } else {
+    datetime::TimeEntityRestoreState temp;
+    this->pref_ =
+        global_preferences->make_preference<datetime::TimeEntityRestoreState>(194434060U ^ this->get_object_id_hash());
+    if (this->pref_.load(&temp)) {
+      temp.apply(this);
+      return;
+    } else {
+      // set to inital value if loading from pref failed
+      state = this->initial_value_;
+    }
+  }
+
+  this->hour_ = state.hour;
+  this->minute_ = state.minute;
+  this->second_ = state.second;
+  this->publish_state();
+}
+
+void TemplateTime::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  this->hour_ = val->hour;
+  this->minute_ = val->minute;
+  this->second_ = val->second;
+  this->publish_state();
+}
+
+void TemplateTime::control(const datetime::TimeCall &call) {
+  bool has_hour = call.get_hour().has_value();
+  bool has_minute = call.get_minute().has_value();
+  bool has_second = call.get_second().has_value();
+
+  ESPTime value = {};
+  if (has_hour)
+    value.hour = *call.get_hour();
+
+  if (has_minute)
+    value.minute = *call.get_minute();
+
+  if (has_second)
+    value.second = *call.get_second();
+
+  this->set_trigger_->trigger(value);
+
+  if (this->optimistic_) {
+    if (has_hour)
+      this->hour_ = *call.get_hour();
+    if (has_minute)
+      this->minute_ = *call.get_minute();
+    if (has_second)
+      this->second_ = *call.get_second();
+    this->publish_state();
+  }
+
+  if (this->restore_value_) {
+    datetime::TimeEntityRestoreState temp = {};
+    if (has_hour) {
+      temp.hour = *call.get_hour();
+    } else {
+      temp.hour = this->hour_;
+    }
+    if (has_minute) {
+      temp.minute = *call.get_minute();
+    } else {
+      temp.minute = this->minute_;
+    }
+    if (has_second) {
+      temp.second = *call.get_second();
+    } else {
+      temp.second = this->second_;
+    }
+
+    this->pref_.save(&temp);
+  }
+}
+
+void TemplateTime::dump_config() {
+  LOG_DATETIME_TIME("", "Template Time", this);
+  ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
+  LOG_UPDATE_INTERVAL(this);
+}
+
+}  // namespace template_
+}  // namespace esphome
+
+#endif  // USE_DATETIME_TIME

esphome/components/template/datetime/template_time.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_DATETIME_TIME
+
+#include "esphome/components/datetime/time_entity.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+#include "esphome/core/time.h"
+
+namespace esphome {
+namespace template_ {
+
+class TemplateTime : public datetime::TimeEntity, public PollingComponent {
+ public:
+  void set_template(std::function<optional<ESPTime>()> &&f) { this->f_ = f; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+
+  void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+
+ protected:
+  void control(const datetime::TimeCall &call) override;
+
+  bool optimistic_{false};
+  ESPTime initial_value_{};
+  bool restore_value_{false};
+  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+  optional<std::function<optional<ESPTime>()>> f_;
+
+  ESPPreferenceObject pref_;
+};
+
+}  // namespace template_
+}  // namespace esphome
+
+#endif  // USE_DATETIME_TIME

esphome/components/text/__init__.py

@@ -73,8 +73,8 @@ async def setup_text_core_(
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
 
-    if CONF_MQTT_ID in config:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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)
 
 

esphome/components/text_sensor/__init__.py

@@ -186,8 +186,8 @@ async def build_filters(config):
 async def setup_text_sensor_core_(var, config):
     await setup_entity(var, config)
 
-    if CONF_DEVICE_CLASS in config:
-        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))
+    if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
+        cg.add(var.set_device_class(device_class))
 
     if config.get(CONF_FILTERS):  # must exist and not be empty
         filters = await build_filters(config[CONF_FILTERS])
@@ -201,8 +201,8 @@ async def setup_text_sensor_core_(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
 
-    if CONF_MQTT_ID in config:
-        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+    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)
 
 

esphome/components/time/__init__.py

@@ -49,7 +49,7 @@ def _load_tzdata(iana_key: str) -> Optional[bytes]:
     package = "tzdata.zoneinfo." + package_loc.replace("/", ".")
 
     try:
-        return resources.read_binary(package, resource)
+        return (resources.files(package) / resource).read_bytes()
     except (FileNotFoundError, ModuleNotFoundError):
         return None
 

esphome/components/tlc5947/__init__.py

@@ -14,7 +14,6 @@ from esphome.const import (
 CONF_LAT_PIN = "lat_pin"
 CONF_OE_PIN = "oe_pin"
 
-AUTO_LOAD = ["output"]
 CODEOWNERS = ["@rnauber"]
 
 tlc5947_ns = cg.esphome_ns.namespace("tlc5947")

esphome/components/tlc5947/output/__init__.py

@@ -2,18 +2,19 @@ import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.components import output
 from esphome.const import CONF_CHANNEL, CONF_ID
-from . import TLC5947
+from .. import TLC5947, tlc5947_ns
 
 DEPENDENCIES = ["tlc5947"]
-CODEOWNERS = ["@rnauber"]
 
-Channel = TLC5947.class_("Channel", output.FloatOutput)
+TLC5947Channel = tlc5947_ns.class_(
+    "TLC5947Channel", output.FloatOutput, cg.Parented.template(TLC5947)
+)
 
 CONF_TLC5947_ID = "tlc5947_id"
 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
     {
         cv.GenerateID(CONF_TLC5947_ID): cv.use_id(TLC5947),
-        cv.Required(CONF_ID): cv.declare_id(Channel),
+        cv.Required(CONF_ID): cv.declare_id(TLC5947Channel),
         cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=65535),
     }
 ).extend(cv.COMPONENT_SCHEMA)
@@ -22,7 +23,5 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await output.register_output(var, config)
-
-    parent = await cg.get_variable(config[CONF_TLC5947_ID])
-    cg.add(var.set_parent(parent))
+    await cg.register_parented(var, config[CONF_TLC5947_ID])
     cg.add(var.set_channel(config[CONF_CHANNEL]))

esphome/components/tlc5947/output/tlc5947_output.cpp

@@ -0,0 +1,12 @@
+#include "tlc5947_output.h"
+
+namespace esphome {
+namespace tlc5947 {
+
+void TLC5947Channel::write_state(float state) {
+  auto amount = static_cast<uint16_t>(state * 0xfff);
+  this->parent_->set_channel_value(this->channel_, amount);
+}
+
+}  // namespace tlc5947
+}  // namespace esphome

esphome/components/tlc5947/output/tlc5947_output.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+
+#include "esphome/components/output/float_output.h"
+
+#include "../tlc5947.h"
+
+namespace esphome {
+namespace tlc5947 {
+
+class TLC5947Channel : public output::FloatOutput, public Parented<TLC5947> {
+ public:
+  void set_channel(uint8_t channel) { this->channel_ = channel; }
+
+ protected:
+  void write_state(float state) override;
+  uint8_t channel_;
+};
+
+}  // namespace tlc5947
+}  // namespace esphome

esphome/components/tlc5947/tlc5947.cpp

@@ -60,5 +60,14 @@ void TLC5947::loop() {
   this->update_ = false;
 }
 
+void TLC5947::set_channel_value(uint16_t channel, uint16_t value) {
+  if (channel >= this->num_chips_ * N_CHANNELS_PER_CHIP)
+    return;
+  if (this->pwm_amounts_[channel] != value) {
+    this->update_ = true;
+  }
+  this->pwm_amounts_[channel] = value;
+}
+
 }  // namespace tlc5947
 }  // namespace esphome

esphome/components/tlc5947/tlc5947.h

@@ -2,18 +2,16 @@
 // TLC5947 24-Channel, 12-Bit PWM LED Driver
 // https://www.ti.com/lit/ds/symlink/tlc5947.pdf
 
+#include <vector>
+#include "esphome/components/output/float_output.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/components/output/float_output.h"
-#include <vector>
 
 namespace esphome {
 namespace tlc5947 {
 
 class TLC5947 : public Component {
  public:
-  class Channel;
-
   const uint8_t N_CHANNELS_PER_CHIP = 24;
 
   void set_data_pin(GPIOPin *data_pin) { data_pin_ = data_pin; }
@@ -31,31 +29,9 @@ class TLC5947 : public Component {
   /// Send new values if they were updated.
   void loop() override;
 
-  class Channel : public output::FloatOutput {
-   public:
-    void set_parent(TLC5947 *parent) { parent_ = parent; }
-    void set_channel(uint8_t channel) { channel_ = channel; }
-
-   protected:
-    void write_state(float state) override {
-      auto amount = static_cast<uint16_t>(state * 0xfff);
-      this->parent_->set_channel_value_(this->channel_, amount);
-    }
-
-    TLC5947 *parent_;
-    uint8_t channel_;
-  };
+  void set_channel_value(uint16_t channel, uint16_t value);
 
  protected:
-  void set_channel_value_(uint16_t channel, uint16_t value) {
-    if (channel >= this->num_chips_ * N_CHANNELS_PER_CHIP)
-      return;
-    if (this->pwm_amounts_[channel] != value) {
-      this->update_ = true;
-    }
-    this->pwm_amounts_[channel] = value;
-  }
-
   GPIOPin *data_pin_;
   GPIOPin *clock_pin_;
   GPIOPin *lat_pin_;

esphome/components/tlc5971/__init__.py

@@ -0,0 +1,40 @@
+# this component is for the "TLC5971 12-Channel, 12-Bit PWM LED Driver" [https://www.ti.com/lit/ds/symlink/tlc5971.pdf],
+# which is used e.g. on [https://www.adafruit.com/product/1455]. The code is based on the TLC5947 component by @rnauber.
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import pins
+from esphome.const import (
+    CONF_CLOCK_PIN,
+    CONF_DATA_PIN,
+    CONF_ID,
+    CONF_NUM_CHIPS,
+)
+
+
+CODEOWNERS = ["@IJIJI"]
+
+tlc5971_ns = cg.esphome_ns.namespace("tlc5971")
+TLC5971 = tlc5971_ns.class_("TLC5971", cg.Component)
+
+MULTI_CONF = True
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(TLC5971),
+        cv.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema,
+        cv.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema,
+        cv.Optional(CONF_NUM_CHIPS, default=1): cv.int_range(min=1, max=85),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    data = await cg.gpio_pin_expression(config[CONF_DATA_PIN])
+    cg.add(var.set_data_pin(data))
+    clock = await cg.gpio_pin_expression(config[CONF_CLOCK_PIN])
+    cg.add(var.set_clock_pin(clock))
+
+    cg.add(var.set_num_chips(config[CONF_NUM_CHIPS]))

esphome/components/tlc5971/output/__init__.py

@@ -0,0 +1,27 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import output
+from esphome.const import CONF_CHANNEL, CONF_ID
+from .. import TLC5971, tlc5971_ns
+
+DEPENDENCIES = ["tlc5971"]
+
+TLC5971Channel = tlc5971_ns.class_(
+    "TLC5971Channel", output.FloatOutput, cg.Parented.template(TLC5971)
+)
+
+CONF_TLC5971_ID = "tlc5971_id"
+CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
+    {
+        cv.GenerateID(CONF_TLC5971_ID): cv.use_id(TLC5971),
+        cv.Required(CONF_ID): cv.declare_id(TLC5971Channel),
+        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=65535),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await output.register_output(var, config)
+    await cg.register_parented(var, config[CONF_TLC5971_ID])
+    cg.add(var.set_channel(config[CONF_CHANNEL]))

esphome/components/tlc5971/output/tlc5971_output.cpp

@@ -0,0 +1,12 @@
+#include "tlc5971_output.h"
+
+namespace esphome {
+namespace tlc5971 {
+
+void TLC5971Channel::write_state(float state) {
+  auto amount = static_cast<uint16_t>(state * 0xffff);
+  this->parent_->set_channel_value(this->channel_, amount);
+}
+
+}  // namespace tlc5971
+}  // namespace esphome

esphome/components/tlc5971/output/tlc5971_output.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/helpers.h"
+
+#include "esphome/components/output/float_output.h"
+
+#include "../tlc5971.h"
+
+namespace esphome {
+namespace tlc5971 {
+
+class TLC5971Channel : public output::FloatOutput, public Parented<TLC5971> {
+ public:
+  void set_channel(uint8_t channel) { this->channel_ = channel; }
+
+ protected:
+  void write_state(float state) override;
+  uint8_t channel_;
+};
+
+}  // namespace tlc5971
+}  // namespace esphome