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

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

esphome/components/uart/switch/uart_switch.cpp

@@ -1,5 +1,6 @@
 #include "uart_switch.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace uart {
@@ -8,7 +9,7 @@ static const char *const TAG = "uart.switch";
 
 void UARTSwitch::loop() {
   if (this->send_every_) {
-    const uint32_t now = millis();
+    const uint32_t now = App.get_loop_component_start_time();
     if (now - this->last_transmission_ > this->send_every_) {
       this->write_command_(this->state);
       this->last_transmission_ = now;

esphome/components/udp/__init__.py

@@ -1,164 +1,162 @@
-import hashlib
-
+from esphome import automation
+from esphome.automation import Trigger
 import esphome.codegen as cg
-from esphome.components.api import CONF_ENCRYPTION
-from esphome.components.binary_sensor import BinarySensor
-from esphome.components.sensor import Sensor
-import esphome.config_validation as cv
-from esphome.const import (
+from esphome.components.packet_transport import (
     CONF_BINARY_SENSORS,
-    CONF_ID,
-    CONF_INTERNAL,
-    CONF_KEY,
-    CONF_NAME,
-    CONF_PORT,
+    CONF_ENCRYPTION,
+    CONF_PING_PONG_ENABLE,
+    CONF_PROVIDERS,
+    CONF_ROLLING_CODE_ENABLE,
     CONF_SENSORS,
 )
-from esphome.cpp_generator import MockObjClass
+import esphome.config_validation as cv
+from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
+from esphome.core import Lambda
+from esphome.cpp_generator import ExpressionStatement, MockObj
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
-AUTO_LOAD = ["socket", "xxtea"]
-MULTI_CONF = True
+AUTO_LOAD = ["socket"]
 
+MULTI_CONF = True
 udp_ns = cg.esphome_ns.namespace("udp")
-UDPComponent = udp_ns.class_("UDPComponent", cg.PollingComponent)
+UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
+UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
+trigger_args = cg.std_vector.template(cg.uint8)
 
-CONF_BROADCAST = "broadcast"
-CONF_BROADCAST_ID = "broadcast_id"
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
-CONF_PROVIDER = "provider"
-CONF_PROVIDERS = "providers"
-CONF_REMOTE_ID = "remote_id"
 CONF_UDP_ID = "udp_id"
-CONF_PING_PONG_ENABLE = "ping_pong_enable"
-CONF_PING_PONG_RECYCLE_TIME = "ping_pong_recycle_time"
-CONF_ROLLING_CODE_ENABLE = "rolling_code_enable"
-
-
-def sensor_validation(cls: MockObjClass):
-    return cv.maybe_simple_value(
-        cv.Schema(
-            {
-                cv.Required(CONF_ID): cv.use_id(cls),
-                cv.Optional(CONF_BROADCAST_ID): cv.validate_id_name,
-            }
-        ),
-        key=CONF_ID,
-    )
-
+CONF_ON_RECEIVE = "on_receive"
+CONF_LISTEN_PORT = "listen_port"
+CONF_BROADCAST_PORT = "broadcast_port"
 
-ENCRYPTION_SCHEMA = {
-    cv.Optional(CONF_ENCRYPTION): cv.maybe_simple_value(
-        cv.Schema(
-            {
-                cv.Required(CONF_KEY): cv.string,
-            }
-        ),
-        key=CONF_KEY,
-    )
-}
-
-PROVIDER_SCHEMA = cv.Schema(
+UDP_SCHEMA = cv.Schema(
     {
-        cv.Required(CONF_NAME): cv.valid_name,
+        cv.GenerateID(CONF_UDP_ID): cv.use_id(UDPComponent),
     }
-).extend(ENCRYPTION_SCHEMA)
+)
 
 
-def validate_(config):
-    if CONF_ENCRYPTION in config:
-        if CONF_SENSORS not in config and CONF_BINARY_SENSORS not in config:
-            raise cv.Invalid("No sensors or binary sensors to encrypt")
-    elif config[CONF_ROLLING_CODE_ENABLE]:
-        raise cv.Invalid("Rolling code requires an encryption key")
-    if config[CONF_PING_PONG_ENABLE]:
-        if not any(CONF_ENCRYPTION in p for p in config.get(CONF_PROVIDERS) or ()):
-            raise cv.Invalid("Ping-pong requires at least one encrypted provider")
-    return config
+def is_relocated(option):
+    def validator(value):
+        raise cv.Invalid(
+            f"The '{option}' option should now be configured in the 'packet_transport' component"
+        )
 
+    return validator
 
-CONFIG_SCHEMA = cv.All(
-    cv.polling_component_schema("15s")
-    .extend(
-        {
-            cv.GenerateID(): cv.declare_id(UDPComponent),
-            cv.Optional(CONF_PORT, default=18511): cv.port,
-            cv.Optional(
-                CONF_LISTEN_ADDRESS, default="255.255.255.255"
-            ): cv.ipv4address_multi_broadcast,
-            cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
-                cv.ipv4address,
-            ),
-            cv.Optional(CONF_ROLLING_CODE_ENABLE, default=False): cv.boolean,
-            cv.Optional(CONF_PING_PONG_ENABLE, default=False): cv.boolean,
-            cv.Optional(
-                CONF_PING_PONG_RECYCLE_TIME, default="600s"
-            ): cv.positive_time_period_seconds,
-            cv.Optional(CONF_SENSORS): cv.ensure_list(sensor_validation(Sensor)),
-            cv.Optional(CONF_BINARY_SENSORS): cv.ensure_list(
-                sensor_validation(BinarySensor)
-            ),
-            cv.Optional(CONF_PROVIDERS): cv.ensure_list(PROVIDER_SCHEMA),
-        },
+
+RELOCATED = {
+    cv.Optional(x): is_relocated(x)
+    for x in (
+        CONF_PROVIDERS,
+        CONF_ENCRYPTION,
+        CONF_PING_PONG_ENABLE,
+        CONF_ROLLING_CODE_ENABLE,
+        CONF_SENSORS,
+        CONF_BINARY_SENSORS,
     )
-    .extend(ENCRYPTION_SCHEMA),
-    validate_,
-)
+}
 
-SENSOR_SCHEMA = cv.Schema(
+CONFIG_SCHEMA = cv.COMPONENT_SCHEMA.extend(
     {
-        cv.Optional(CONF_REMOTE_ID): cv.string_strict,
-        cv.Required(CONF_PROVIDER): cv.valid_name,
-        cv.GenerateID(CONF_UDP_ID): cv.use_id(UDPComponent),
+        cv.GenerateID(): cv.declare_id(UDPComponent),
+        cv.Optional(CONF_PORT, default=18511): cv.Any(
+            cv.port,
+            cv.Schema(
+                {
+                    cv.Required(CONF_LISTEN_PORT): cv.port,
+                    cv.Required(CONF_BROADCAST_PORT): cv.port,
+                }
+            ),
+        ),
+        cv.Optional(
+            CONF_LISTEN_ADDRESS, default="255.255.255.255"
+        ): cv.ipv4address_multi_broadcast,
+        cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
+            cv.ipv4address,
+        ),
+        cv.Optional(CONF_ON_RECEIVE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    Trigger.template(trigger_args)
+                ),
+            }
+        ),
     }
-)
-
+).extend(RELOCATED)
 
-def require_internal_with_name(config):
-    if CONF_NAME in config and CONF_INTERNAL not in config:
-        raise cv.Invalid("Must provide internal: config when using name:")
-    return config
 
-
-def hash_encryption_key(config: dict):
-    return list(hashlib.sha256(config[CONF_KEY].encode()).digest())
+async def register_udp_client(var, config):
+    udp_var = await cg.get_variable(config[CONF_UDP_ID])
+    cg.add(var.set_parent(udp_var))
+    return udp_var
 
 
 async def to_code(config):
     cg.add_define("USE_UDP")
     cg.add_global(udp_ns.using)
     var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    cg.add(var.set_port(config[CONF_PORT]))
-    cg.add(var.set_rolling_code_enable(config[CONF_ROLLING_CODE_ENABLE]))
-    cg.add(var.set_ping_pong_enable(config[CONF_PING_PONG_ENABLE]))
-    cg.add(
-        var.set_ping_pong_recycle_time(
-            config[CONF_PING_PONG_RECYCLE_TIME].total_seconds
-        )
-    )
-    for sens_conf in config.get(CONF_SENSORS, ()):
-        sens_id = sens_conf[CONF_ID]
-        sensor = await cg.get_variable(sens_id)
-        bcst_id = sens_conf.get(CONF_BROADCAST_ID, sens_id.id)
-        cg.add(var.add_sensor(bcst_id, sensor))
-    for sens_conf in config.get(CONF_BINARY_SENSORS, ()):
-        sens_id = sens_conf[CONF_ID]
-        sensor = await cg.get_variable(sens_id)
-        bcst_id = sens_conf.get(CONF_BROADCAST_ID, sens_id.id)
-        cg.add(var.add_binary_sensor(bcst_id, sensor))
+    var = await cg.register_component(var, config)
+    conf_port = config[CONF_PORT]
+    if isinstance(conf_port, int):
+        cg.add(var.set_listen_port(conf_port))
+        cg.add(var.set_broadcast_port(conf_port))
+    else:
+        cg.add(var.set_listen_port(conf_port[CONF_LISTEN_PORT]))
+        cg.add(var.set_broadcast_port(conf_port[CONF_BROADCAST_PORT]))
+    if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
+        cg.add(var.set_listen_address(listen_address))
     for address in config[CONF_ADDRESSES]:
         cg.add(var.add_address(str(address)))
+    if on_receive := config.get(CONF_ON_RECEIVE):
+        on_receive = on_receive[0]
+        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger = await automation.build_automation(
+            trigger, [(trigger_args, "data")], on_receive
+        )
+        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
+        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
+        cg.add(var.add_listener(trigger))
+        cg.add(var.set_should_listen())
+
+
+def validate_raw_data(value):
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return cv.Schema([cv.hex_uint8_t])(value)
+    raise cv.Invalid(
+        "data must either be a string wrapped in quotes or a list of bytes"
+    )
 
-    if encryption := config.get(CONF_ENCRYPTION):
-        cg.add(var.set_encryption_key(hash_encryption_key(encryption)))
 
-    for provider in config.get(CONF_PROVIDERS, ()):
-        name = provider[CONF_NAME]
-        cg.add(var.add_provider(name))
-        if (listen_address := str(config[CONF_LISTEN_ADDRESS])) != "255.255.255.255":
-            cg.add(var.set_listen_address(listen_address))
-        if encryption := provider.get(CONF_ENCRYPTION):
-            cg.add(var.set_provider_encryption(name, hash_encryption_key(encryption)))
+@automation.register_action(
+    "udp.write",
+    UDPWriteAction,
+    cv.maybe_simple_value(
+        {
+            cv.GenerateID(): cv.use_id(UDPComponent),
+            cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+        },
+        key=CONF_DATA,
+    ),
+)
+async def udp_write_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    udp_var = await cg.get_variable(config[CONF_ID])
+    await cg.register_parented(var, udp_var)
+    cg.add(udp_var.set_should_broadcast())
+    data = config[CONF_DATA]
+    if isinstance(data, bytes):
+        data = list(data)
+
+    if cg.is_template(data):
+        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
+        cg.add(var.set_data_template(templ))
+    else:
+        cg.add(var.set_data_static(data))
+    return var

esphome/components/udp/automation.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "udp_component.h"
+#ifdef USE_NETWORK
+#include "esphome/core/automation.h"
+
+#include <vector>
+
+namespace esphome {
+namespace udp {
+
+template<typename... Ts> class UDPWriteAction : public Action<Ts...>, public Parented<UDPComponent> {
+ public:
+  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) {
+    this->data_func_ = func;
+    this->static_ = false;
+  }
+  void set_data_static(const std::vector<uint8_t> &data) {
+    this->data_static_ = data;
+    this->static_ = true;
+  }
+
+  void play(Ts... x) override {
+    if (this->static_) {
+      this->parent_->send_packet(this->data_static_);
+    } else {
+      auto val = this->data_func_(x...);
+      this->parent_->send_packet(val);
+    }
+  }
+
+ protected:
+  bool static_{false};
+  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
+  std::vector<uint8_t> data_static_{};
+};
+
+}  // namespace udp
+}  // namespace esphome
+#endif

esphome/components/udp/binary_sensor.py

@@ -1,27 +1,5 @@
-import esphome.codegen as cg
-from esphome.components import binary_sensor
-from esphome.config_validation import All, has_at_least_one_key
-from esphome.const import CONF_ID
+import esphome.config_validation as cv
 
-from . import (
-    CONF_PROVIDER,
-    CONF_REMOTE_ID,
-    CONF_UDP_ID,
-    SENSOR_SCHEMA,
-    require_internal_with_name,
+CONFIG_SCHEMA = cv.invalid(
+    "The 'udp.binary_sensor' component has been migrated to the 'packet_transport.binary_sensor' component."
 )
-
-DEPENDENCIES = ["udp"]
-
-CONFIG_SCHEMA = All(
-    binary_sensor.binary_sensor_schema().extend(SENSOR_SCHEMA),
-    has_at_least_one_key(CONF_ID, CONF_REMOTE_ID),
-    require_internal_with_name,
-)
-
-
-async def to_code(config):
-    var = await binary_sensor.new_binary_sensor(config)
-    comp = await cg.get_variable(config[CONF_UDP_ID])
-    remote_id = str(config.get(CONF_REMOTE_ID) or config.get(CONF_ID))
-    cg.add(comp.add_remote_binary_sensor(config[CONF_PROVIDER], remote_id, var))

esphome/components/udp/packet_transport/__init__.py

@@ -0,0 +1,29 @@
+import esphome.codegen as cg
+from esphome.components.api import CONF_ENCRYPTION
+from esphome.components.packet_transport import (
+    CONF_PING_PONG_ENABLE,
+    PacketTransport,
+    new_packet_transport,
+    transport_schema,
+)
+from esphome.const import CONF_BINARY_SENSORS, CONF_SENSORS
+from esphome.cpp_types import PollingComponent
+
+from .. import UDP_SCHEMA, register_udp_client, udp_ns
+
+UDPTransport = udp_ns.class_("UDPTransport", PacketTransport, PollingComponent)
+
+CONFIG_SCHEMA = transport_schema(UDPTransport).extend(UDP_SCHEMA)
+
+
+async def to_code(config):
+    var, providers = await new_packet_transport(config)
+    udp_var = await register_udp_client(var, config)
+    if CONF_ENCRYPTION in config or providers:
+        cg.add(udp_var.set_should_listen())
+    if (
+        config[CONF_PING_PONG_ENABLE]
+        or config.get(CONF_SENSORS, ())
+        or config.get(CONF_BINARY_SENSORS, ())
+    ):
+        cg.add(udp_var.set_should_broadcast())