esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/text/__init__.py

@@ -5,6 +5,8 @@ import esphome.codegen as cg
 from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_MODE,
     CONF_MQTT_ID,
@@ -14,6 +16,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@mauritskorse"]
@@ -39,7 +42,7 @@ TEXT_MODES = {
     "PASSWORD": TextMode.TEXT_MODE_PASSWORD,  # to be implemented for keys, passwords, etc.
 }
 
-TEXT_SCHEMA = (
+_TEXT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -57,6 +60,34 @@ TEXT_SCHEMA = (
 )
 
 
+def text_schema(
+    class_: MockObjClass = cv.UNDEFINED,
+    *,
+    icon: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    mode: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_MODE, mode, cv.enum(TEXT_MODES, upper=True)),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _TEXT_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+TEXT_SCHEMA = text_schema()
+TEXT_SCHEMA.add_extra(cv.deprecated_schema_constant("text"))
+
+
 async def setup_text_core_(
     var,
     config,

esphome/components/text_sensor/__init__.py

@@ -125,7 +125,7 @@ async def map_filter_to_code(config, filter_id):
 
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
-TEXT_SENSOR_SCHEMA = (
+_TEXT_SENSOR_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
     .extend(
@@ -152,38 +152,33 @@ TEXT_SENSOR_SCHEMA = (
     )
 )
 
-_UNDEF = object()
-
 
 def text_sensor_schema(
-    class_: MockObjClass = _UNDEF,
+    class_: MockObjClass = cv.UNDEFINED,
     *,
-    icon: str = _UNDEF,
-    entity_category: str = _UNDEF,
-    device_class: str = _UNDEF,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
 ) -> cv.Schema:
-    schema = TEXT_SENSOR_SCHEMA
-    if class_ is not _UNDEF:
-        schema = schema.extend({cv.GenerateID(): cv.declare_id(class_)})
-    if icon is not _UNDEF:
-        schema = schema.extend({cv.Optional(CONF_ICON, default=icon): cv.icon})
-    if device_class is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_DEVICE_CLASS, default=device_class
-                ): validate_device_class
-            }
-        )
-    if entity_category is not _UNDEF:
-        schema = schema.extend(
-            {
-                cv.Optional(
-                    CONF_ENTITY_CATEGORY, default=entity_category
-                ): cv.entity_category
-            }
-        )
-    return schema
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_DEVICE_CLASS, device_class, validate_device_class),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _TEXT_SENSOR_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+TEXT_SENSOR_SCHEMA = text_sensor_schema()
+TEXT_SENSOR_SCHEMA.add_extra(cv.deprecated_schema_constant("text_sensor"))
 
 
 async def build_filters(config):

esphome/components/thermostat/climate.py

@@ -516,9 +516,9 @@ def validate_thermostat(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    climate.CLIMATE_SCHEMA.extend(
+    climate.climate_schema(ThermostatClimate)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(ThermostatClimate),
             cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
             cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
             cv.Required(CONF_IDLE_ACTION): automation.validate_automation(single=True),
@@ -631,7 +631,8 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(
         CONF_COOL_ACTION, CONF_DRY_ACTION, CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION
     ),
@@ -640,9 +641,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
 
     heat_cool_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
     two_points_available = CONF_HEAT_ACTION in config and (

esphome/components/time_based/cover.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_ASSUMED_STATE,
     CONF_CLOSE_ACTION,
     CONF_CLOSE_DURATION,
-    CONF_ID,
     CONF_OPEN_ACTION,
     CONF_OPEN_DURATION,
     CONF_STOP_ACTION,
@@ -18,25 +17,27 @@ TimeBasedCover = time_based_ns.class_("TimeBasedCover", cover.Cover, cg.Componen
 CONF_HAS_BUILT_IN_ENDSTOP = "has_built_in_endstop"
 CONF_MANUAL_CONTROL = "manual_control"
 
-CONFIG_SCHEMA = cover.COVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TimeBasedCover),
-        cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
-        cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
-        cv.Optional(CONF_MANUAL_CONTROL, default=False): cv.boolean,
-        cv.Optional(CONF_ASSUMED_STATE, default=True): cv.boolean,
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    cover.cover_schema(TimeBasedCover)
+    .extend(
+        {
+            cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
+            cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
+            cv.Optional(CONF_MANUAL_CONTROL, default=False): cv.boolean,
+            cv.Optional(CONF_ASSUMED_STATE, default=True): cv.boolean,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     await automation.build_automation(
         var.get_stop_trigger(), [], config[CONF_STOP_ACTION]

esphome/components/tm1638/switch/__init__.py

@@ -8,13 +8,16 @@ from ..display import CONF_TM1638_ID, TM1638Component, tm1638_ns
 TM1638SwitchLed = tm1638_ns.class_("TM1638SwitchLed", switch.Switch, cg.Component)
 
 
-CONFIG_SCHEMA = switch.SWITCH_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(TM1638SwitchLed),
-        cv.GenerateID(CONF_TM1638_ID): cv.use_id(TM1638Component),
-        cv.Required(CONF_LED): cv.int_range(min=0, max=7),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_SCHEMA = (
+    switch.switch_schema(TM1638SwitchLed)
+    .extend(
+        {
+            cv.GenerateID(CONF_TM1638_ID): cv.use_id(TM1638Component),
+            cv.Required(CONF_LED): cv.int_range(min=0, max=7),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 async def to_code(config):

esphome/components/tormatic/cover.py

@@ -1,17 +1,17 @@
 import esphome.codegen as cg
 from esphome.components import cover, uart
 import esphome.config_validation as cv
-from esphome.const import CONF_CLOSE_DURATION, CONF_ID, CONF_OPEN_DURATION
+from esphome.const import CONF_CLOSE_DURATION, CONF_OPEN_DURATION
 
 tormatic_ns = cg.esphome_ns.namespace("tormatic")
 Tormatic = tormatic_ns.class_("Tormatic", cover.Cover, cg.PollingComponent)
 
 CONFIG_SCHEMA = (
-    cover.COVER_SCHEMA.extend(uart.UART_DEVICE_SCHEMA)
+    cover.cover_schema(Tormatic)
+    .extend(uart.UART_DEVICE_SCHEMA)
     .extend(cv.polling_component_schema("300ms"))
     .extend(
         {
-            cv.GenerateID(): cv.declare_id(Tormatic),
             cv.Optional(
                 CONF_OPEN_DURATION, default="15s"
             ): cv.positive_time_period_milliseconds,
@@ -34,9 +34,8 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
     await uart.register_uart_device(var, config)
 
     cg.add(var.set_close_duration(config[CONF_CLOSE_DURATION]))

esphome/components/toshiba/climate.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import climate_ir
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_MODEL
+from esphome.const import CONF_MODEL
 
 AUTO_LOAD = ["climate_ir"]
 CODEOWNERS = ["@kbx81"]
@@ -16,15 +16,13 @@ MODELS = {
     "RAC-PT1411HWRU-F": Model.MODEL_RAC_PT1411HWRU_F,
 }
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
+CONFIG_SCHEMA = climate_ir.climare_ir_with_receiver_schema(ToshibaClimate).extend(
     {
-        cv.GenerateID(): cv.declare_id(ToshibaClimate),
         cv.Optional(CONF_MODEL, default="generic"): cv.enum(MODELS, upper=True),
     }
 )
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await climate_ir.register_climate_ir(var, config)
+    var = await climate_ir.new_climate_ir(config)
     cg.add(var.set_model(config[CONF_MODEL]))

esphome/components/touchscreen/touchscreen.cpp

@@ -50,13 +50,15 @@ void Touchscreen::loop() {
       tp.second.x_prev = tp.second.x;
       tp.second.y_prev = tp.second.y;
     }
+    // The interrupt flag must be reset BEFORE calling update_touches, otherwise we might miss an interrupt that was
+    // triggered while we were reading touch data.
+    this->store_.touched = false;
     this->update_touches();
     if (this->skip_update_) {
       for (auto &tp : this->touches_) {
         tp.second.state &= ~STATE_RELEASING;
       }
     } else {
-      this->store_.touched = false;
       this->defer([this]() { this->send_touches_(); });
       if (this->touch_timeout_ > 0) {
         // Simulate a touch after <this->touch_timeout_> ms. This will reset any existing timeout operation.

esphome/components/tt21100/touchscreen/tt21100.cpp

@@ -68,7 +68,7 @@ void TT21100Touchscreen::setup() {
       this->x_raw_max_ = this->display_->get_native_width();
     }
     if (this->y_raw_max_ == this->y_raw_min_) {
-      this->x_raw_max_ = this->display_->get_native_height();
+      this->y_raw_max_ = this->display_->get_native_height();
     }
   }
 

esphome/components/tuya/climate/__init__.py

@@ -4,7 +4,6 @@ from esphome.components import climate
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FAN_MODE,
-    CONF_ID,
     CONF_PRESET,
     CONF_SUPPORTS_COOL,
     CONF_SUPPORTS_HEAT,
@@ -151,9 +150,9 @@ SWING_MODES = cv.Schema(
 )
 
 CONFIG_SCHEMA = cv.All(
-    climate.CLIMATE_SCHEMA.extend(
+    climate.climate_schema(TuyaClimate)
+    .extend(
         {
-            cv.GenerateID(): cv.declare_id(TuyaClimate),
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
             cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean,
             cv.Optional(CONF_SUPPORTS_COOL, default=False): cv.boolean,
@@ -186,7 +185,8 @@ CONFIG_SCHEMA = cv.All(
                 "'eco_temperature' has been moved inside of the 'eco' config block under 'preset' as 'temperature'"
             ),
         }
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TARGET_TEMPERATURE_DATAPOINT, CONF_SWITCH_DATAPOINT),
     validate_temperature_multipliers,
     validate_cooling_values,
@@ -194,9 +194,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
 
     paren = await cg.get_variable(config[CONF_TUYA_ID])
     cg.add(var.set_tuya_parent(paren))

esphome/components/tuya/cover/__init__.py

@@ -1,12 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import cover
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_MAX_VALUE,
-    CONF_MIN_VALUE,
-    CONF_OUTPUT_ID,
-    CONF_RESTORE_MODE,
-)
+from esphome.const import CONF_MAX_VALUE, CONF_MIN_VALUE, CONF_RESTORE_MODE
 
 from .. import CONF_TUYA_ID, Tuya, tuya_ns
 
@@ -38,9 +33,9 @@ def validate_range(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    cover.COVER_SCHEMA.extend(
+    cover.cover_schema(TuyaCover)
+    .extend(
         {
-            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(TuyaCover),
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
             cv.Optional(CONF_CONTROL_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t,
@@ -54,15 +49,15 @@ CONFIG_SCHEMA = cv.All(
                 RESTORE_MODES, upper=True
             ),
         },
-    ).extend(cv.COMPONENT_SCHEMA),
+    )
+    .extend(cv.COMPONENT_SCHEMA),
     validate_range,
 )
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     if CONF_CONTROL_DATAPOINT in config:
         cg.add(var.set_control_id(config[CONF_CONTROL_DATAPOINT]))

esphome/components/tuya/select/__init__.py

@@ -1,7 +1,12 @@
 import esphome.codegen as cg
 from esphome.components import select
 import esphome.config_validation as cv
-from esphome.const import CONF_ENUM_DATAPOINT, CONF_OPTIMISTIC, CONF_OPTIONS
+from esphome.const import (
+    CONF_ENUM_DATAPOINT,
+    CONF_INT_DATAPOINT,
+    CONF_OPTIMISTIC,
+    CONF_OPTIONS,
+)
 
 from .. import CONF_TUYA_ID, Tuya, tuya_ns
 
@@ -26,17 +31,19 @@ def ensure_option_map(value):
     return value
 
 
-CONFIG_SCHEMA = (
+CONFIG_SCHEMA = cv.All(
     select.select_schema(TuyaSelect)
     .extend(
         {
             cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
-            cv.Required(CONF_ENUM_DATAPOINT): cv.uint8_t,
+            cv.Optional(CONF_ENUM_DATAPOINT): cv.uint8_t,
+            cv.Optional(CONF_INT_DATAPOINT): cv.uint8_t,
             cv.Required(CONF_OPTIONS): ensure_option_map,
             cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
         }
     )
-    .extend(cv.COMPONENT_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.has_exactly_one_key(CONF_ENUM_DATAPOINT, CONF_INT_DATAPOINT),
 )
 
 
@@ -47,5 +54,8 @@ async def to_code(config):
     cg.add(var.set_select_mappings(list(options_map.keys())))
     parent = await cg.get_variable(config[CONF_TUYA_ID])
     cg.add(var.set_tuya_parent(parent))
-    cg.add(var.set_select_id(config[CONF_ENUM_DATAPOINT]))
+    if enum_datapoint := config.get(CONF_ENUM_DATAPOINT, None) is not None:
+        cg.add(var.set_select_id(enum_datapoint, False))
+    if int_datapoint := config.get(CONF_INT_DATAPOINT, None) is not None:
+        cg.add(var.set_select_id(int_datapoint, True))
     cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))

esphome/components/tuya/select/tuya_select.cpp

@@ -31,7 +31,11 @@ void TuyaSelect::control(const std::string &value) {
   if (idx.has_value()) {
     uint8_t mapping = this->mappings_.at(idx.value());
     ESP_LOGV(TAG, "Setting %u datapoint value to %u:%s", this->select_id_, mapping, value.c_str());
-    this->parent_->set_enum_datapoint_value(this->select_id_, mapping);
+    if (this->is_int_) {
+      this->parent_->set_integer_datapoint_value(this->select_id_, mapping);
+    } else {
+      this->parent_->set_enum_datapoint_value(this->select_id_, mapping);
+    }
     return;
   }
 
@@ -41,6 +45,7 @@ void TuyaSelect::control(const std::string &value) {
 void TuyaSelect::dump_config() {
   LOG_SELECT("", "Tuya Select", this);
   ESP_LOGCONFIG(TAG, "  Select has datapoint ID %u", this->select_id_);
+  ESP_LOGCONFIG(TAG, "  Data type: %s", this->is_int_ ? "int" : "enum");
   ESP_LOGCONFIG(TAG, "  Options are:");
   auto options = this->traits.get_options();
   for (auto i = 0; i < this->mappings_.size(); i++) {

esphome/components/tuya/select/tuya_select.h

@@ -16,7 +16,10 @@ class TuyaSelect : public select::Select, public Component {
 
   void set_tuya_parent(Tuya *parent) { this->parent_ = parent; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_select_id(uint8_t select_id) { this->select_id_ = select_id; }
+  void set_select_id(uint8_t select_id, bool is_int) {
+    this->select_id_ = select_id;
+    this->is_int_ = is_int;
+  }
   void set_select_mappings(std::vector<uint8_t> mappings) { this->mappings_ = std::move(mappings); }
 
  protected:
@@ -26,6 +29,7 @@ class TuyaSelect : public select::Select, public Component {
   bool optimistic_ = false;
   uint8_t select_id_;
   std::vector<uint8_t> mappings_;
+  bool is_int_ = false;
 };
 
 }  // namespace tuya

esphome/components/uart/packet_transport/__init__.py

@@ -0,0 +1,20 @@
+from esphome.components.packet_transport import (
+    PacketTransport,
+    new_packet_transport,
+    transport_schema,
+)
+from esphome.cpp_types import PollingComponent
+
+from .. import UART_DEVICE_SCHEMA, register_uart_device, uart_ns
+
+CODEOWNERS = ["@clydebarrow"]
+DEPENDENCIES = ["uart"]
+
+UARTTransport = uart_ns.class_("UARTTransport", PacketTransport, PollingComponent)
+
+CONFIG_SCHEMA = transport_schema(UARTTransport).extend(UART_DEVICE_SCHEMA)
+
+
+async def to_code(config):
+    var, _ = await new_packet_transport(config)
+    await register_uart_device(var, config)

esphome/components/uart/packet_transport/uart_transport.cpp

@@ -0,0 +1,88 @@
+#include "esphome/core/log.h"
+#include "esphome/core/application.h"
+#include "uart_transport.h"
+
+namespace esphome {
+namespace uart {
+
+static const char *const TAG = "uart_transport";
+
+void UARTTransport::loop() {
+  PacketTransport::loop();
+
+  while (this->parent_->available()) {
+    uint8_t byte;
+    if (!this->parent_->read_byte(&byte)) {
+      ESP_LOGW(TAG, "Failed to read byte from UART");
+      return;
+    }
+    if (byte == FLAG_BYTE) {
+      if (this->rx_started_ && this->receive_buffer_.size() > 6) {
+        auto len = this->receive_buffer_.size();
+        auto crc = crc16(this->receive_buffer_.data(), len - 2);
+        if (crc != (this->receive_buffer_[len - 2] | (this->receive_buffer_[len - 1] << 8))) {
+          ESP_LOGD(TAG, "CRC mismatch, discarding packet");
+          this->rx_started_ = false;
+          this->receive_buffer_.clear();
+          continue;
+        }
+        this->receive_buffer_.resize(len - 2);
+        this->process_(this->receive_buffer_);
+        this->rx_started_ = false;
+      } else {
+        this->rx_started_ = true;
+      }
+      this->receive_buffer_.clear();
+      this->rx_control_ = false;
+      continue;
+    }
+    if (!this->rx_started_)
+      continue;
+    if (byte == CONTROL_BYTE) {
+      this->rx_control_ = true;
+      continue;
+    }
+    if (this->rx_control_) {
+      byte ^= 0x20;
+      this->rx_control_ = false;
+    }
+    if (this->receive_buffer_.size() == MAX_PACKET_SIZE) {
+      ESP_LOGD(TAG, "Packet too large, discarding");
+      this->rx_started_ = false;
+      this->receive_buffer_.clear();
+      continue;
+    }
+    this->receive_buffer_.push_back(byte);
+  }
+}
+
+void UARTTransport::update() {
+  this->updated_ = true;
+  this->resend_data_ = true;
+  PacketTransport::update();
+}
+
+/**
+ * Write a byte to the UART bus. If the byte is a flag or control byte, it will be escaped.
+ * @param byte The byte to write.
+ */
+void UARTTransport::write_byte_(uint8_t byte) const {
+  if (byte == FLAG_BYTE || byte == CONTROL_BYTE) {
+    this->parent_->write_byte(CONTROL_BYTE);
+    byte ^= 0x20;
+  }
+  this->parent_->write_byte(byte);
+}
+
+void UARTTransport::send_packet(const std::vector<uint8_t> &buf) const {
+  this->parent_->write_byte(FLAG_BYTE);
+  for (uint8_t byte : buf) {
+    this->write_byte_(byte);
+  }
+  auto crc = crc16(buf.data(), buf.size());
+  this->write_byte_(crc & 0xFF);
+  this->write_byte_(crc >> 8);
+  this->parent_->write_byte(FLAG_BYTE);
+}
+}  // namespace uart
+}  // namespace esphome

esphome/components/uart/packet_transport/uart_transport.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/packet_transport/packet_transport.h"
+#include <vector>
+#include "../uart.h"
+
+namespace esphome {
+namespace uart {
+
+/**
+ * A transport protocol for sending and receiving packets over a UART connection.
+ * The protocol is based on Asynchronous HDLC framing. (https://en.wikipedia.org/wiki/High-Level_Data_Link_Control)
+ * There are two special bytes: FLAG_BYTE and CONTROL_BYTE.
+ * A 16-bit CRC is appended to the packet, then
+ * the protocol wraps the resulting data between FLAG_BYTEs.
+ * Any occurrence of FLAG_BYTE or CONTROL_BYTE in the data is escaped by emitting CONTROL_BYTE followed by the byte
+ * XORed with 0x20.
+ */
+static const uint16_t MAX_PACKET_SIZE = 508;
+static const uint8_t FLAG_BYTE = 0x7E;
+static const uint8_t CONTROL_BYTE = 0x7D;
+
+class UARTTransport : public packet_transport::PacketTransport, public UARTDevice {
+ public:
+  void loop() override;
+  void update() override;
+  float get_setup_priority() const override { return setup_priority::PROCESSOR; }
+
+ protected:
+  void write_byte_(uint8_t byte) const;
+  void send_packet(const std::vector<uint8_t> &buf) const override;
+  bool should_send() override { return true; };
+  size_t get_max_packet_size() override { return MAX_PACKET_SIZE; }
+  std::vector<uint8_t> receive_buffer_{};
+  bool rx_started_{};
+  bool rx_control_{};
+};
+
+}  // namespace uart
+}  // namespace esphome