[display] Loop on the reader's step in display drivers and cap mipi_spi args in the reader

The bool API cost flash at every call site (about 10 B per mipi_spi
instantiation on ESP8266); the unscoped enum keeps the old code shape and
lets callers loop with while (auto step = reader.next(entry)).

CODEOWNERS

@@ -187,7 +187,6 @@ esphome/components/ens160_base/* @latonita @vincentscode
 esphome/components/ens160_i2c/* @latonita
 esphome/components/ens160_spi/* @latonita
 esphome/components/ens210/* @itn3rd77
-esphome/components/entity_transport/* @clydebarrow
 esphome/components/epaper_spi/* @esphome/core
 esphome/components/es7210/* @kahrendt
 esphome/components/es7243e/* @kbx81
@@ -213,7 +212,6 @@ esphome/components/esp_ldo/* @clydebarrow
 esphome/components/espectre/* @francescopace
 esphome/components/esphome/ota/* @esphome/core
 esphome/components/espnow/* @jesserockz
-esphome/components/espnow/packet_interface/* @clydebarrow
 esphome/components/espnow/packet_transport/* @EasilyBoredEngineer
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/event/* @nohat
@@ -464,8 +462,6 @@ esphome/components/openthread/* @mrene
 esphome/components/opt3001/* @ccutrer
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
-esphome/components/packet_interface/* @clydebarrow
-esphome/components/packet_interface/packet_transport/* @clydebarrow
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
 esphome/components/pca9505/* @ajfriesen @ssieb
@@ -631,9 +627,7 @@ esphome/components/sun_gtil2/* @Mat931
 esphome/components/switch/* @esphome/core
 esphome/components/switch/binary_sensor/* @ssieb
 esphome/components/sx126x/* @swoboda1337
-esphome/components/sx126x/packet_interface/* @clydebarrow
 esphome/components/sx127x/* @swoboda1337
-esphome/components/sx127x/packet_interface/* @clydebarrow
 esphome/components/sy6970/* @linkedupbits
 esphome/components/syslog/* @clydebarrow
 esphome/components/systa_bus/* @Mat931
@@ -645,8 +639,6 @@ esphome/components/tca8418/* @zebble
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski
 esphome/components/tcl112/* @glmnet
-esphome/components/tcp/* @clydebarrow
-esphome/components/tcp/packet_interface/* @clydebarrow
 esphome/components/tcp_uart/* @Bascht74
 esphome/components/tee501/* @Stock-M
 esphome/components/teleinfo/* @0hax @FredM67
@@ -690,12 +682,10 @@ esphome/components/tuya/water_heater/* @iago-veiga
 esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
-esphome/components/uart/packet_interface/* @clydebarrow
 esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/uart_mux/* @kbx81
 esphome/components/uart_tcp/* @Bascht74
 esphome/components/udp/* @clydebarrow
-esphome/components/udp/packet_interface/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
 esphome/components/ufm01/* @ljungqvist

esphome/components/display/__init__.py

@@ -181,6 +181,16 @@ def get_all_display_metadata() -> dict[str, DisplayMetaData]:
     return {id_.id: meta for id_, meta in entries}
 
 
+def config_has_writer(config: ConfigType) -> bool:
+    """Return True when the display config draws anything."""
+    return (
+        config.get(CONF_AUTO_CLEAR_ENABLED) is True
+        or config.get(CONF_PAGES) is not None
+        or config.get(CONF_LAMBDA) is not None
+        or config.get(CONF_SHOW_TEST_CARD) is True
+    )
+
+
 def get_display_metadata(display_id: ID) -> DisplayMetaData:
     """Get display metadata by ID object
 
@@ -210,10 +220,7 @@ def get_display_metadata(display_id: ID) -> DisplayMetaData:
         height=dimensions[1],
         has_hardware_rotation=False,
         byte_order=disp_config.get(CONF_BYTE_ORDER, cv.UNDEFINED),
-        has_writer=disp_config.get(CONF_AUTO_CLEAR_ENABLED) is True
-        or disp_config.get(CONF_PAGES) is not None
-        or disp_config.get(CONF_LAMBDA) is not None
-        or disp_config.get(CONF_SHOW_TEST_CARD) is True,
+        has_writer=config_has_writer(disp_config),
         rotation=disp_config.get(CONF_ROTATION, 0),
         draw_rounding=disp_config.get(CONF_DRAW_ROUNDING, 0),
     )

esphome/components/display/init_sequence.cpp

@@ -0,0 +1,28 @@
+#include "init_sequence.h"
+#include "esphome/core/hal.h"
+
+namespace esphome::display {
+
+InitSequenceStep InitSequenceReader::next(InitSequenceEntry &entry, uint8_t max_count) {
+  const size_t remaining = this->length_ - this->index_;
+  if (remaining == 0)
+    return INIT_SEQUENCE_STEP_END;
+  const uint8_t *pos = this->sequence_ + this->index_;
+  if (remaining >= 2) {
+    entry.value = progmem_read_byte(pos);
+    entry.count = progmem_read_byte(pos + 1);
+    entry.args = pos + 2;
+    if (entry.count == INIT_SEQUENCE_DELAY_FLAG) {
+      this->index_ += 2;
+      return INIT_SEQUENCE_STEP_DELAY;
+    }
+    if (entry.count <= max_count && remaining - 2 >= entry.count) {
+      this->index_ += 2 + entry.count;
+      return INIT_SEQUENCE_STEP_COMMAND;
+    }
+  }
+  this->index_ = this->length_;
+  return INIT_SEQUENCE_STEP_MALFORMED;
+}
+
+}  // namespace esphome::display

esphome/components/display/init_sequence.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace esphome::display {
+
+/// Count byte that marks a delay entry: the byte before it is the delay in ms.
+static constexpr uint8_t INIT_SEQUENCE_DELAY_FLAG = 0xFF;
+
+/// Unscoped so `while (auto step = reader.next(entry))` stops at END.
+enum InitSequenceStep : uint8_t {
+  INIT_SEQUENCE_STEP_END = 0,
+  INIT_SEQUENCE_STEP_COMMAND,
+  INIT_SEQUENCE_STEP_DELAY,
+  INIT_SEQUENCE_STEP_MALFORMED,
+};
+
+/// `value` is the command or the delay in ms; `args` points into the (possibly PROGMEM) sequence.
+struct InitSequenceEntry {
+  const uint8_t *args;
+  uint8_t value;
+  uint8_t count;
+};
+
+/// Walks a mipi.flatten_sequence table (`cmd, count, args...` or `ms, 0xFF`) with progmem reads; resumable.
+class InitSequenceReader {
+ public:
+  InitSequenceReader(const uint8_t *sequence, size_t length) : sequence_(sequence), length_(length) {}
+
+  /// Fill `entry` with the next entry; a command with more than `max_count` args is MALFORMED.
+  InitSequenceStep next(InitSequenceEntry &entry, uint8_t max_count = 0xFE);
+
+ protected:
+  const uint8_t *sequence_;
+  size_t length_;
+  size_t index_{0};
+};
+
+}  // namespace esphome::display

esphome/components/entity_transport/__init__.py

@@ -1,177 +0,0 @@
-"""Send sensor and binary sensor states to other devices over a packet interface."""
-
-from collections.abc import Callable
-from typing import Any
-
-import esphome.codegen as cg
-from esphome.components import packet_interface
-from esphome.components.binary_sensor import BinarySensor
-from esphome.components.const import CONF_PROVIDER, CONF_REMOTE_ID
-from esphome.components.packet_interface import (
-    CONF_PACKET_INTERFACE,
-    final_validate_interface,
-    interface_has_layer,
-)
-from esphome.components.packet_interface.layers import CONF_SESSION
-from esphome.components.sensor import Sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BINARY_SENSORS,
-    CONF_ID,
-    CONF_SENSORS,
-    CONF_TIMEOUT,
-    CONF_UPDATE_INTERVAL,
-)
-from esphome.cpp_generator import MockObj, MockObjClass
-from esphome.types import ConfigType
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["packet_interface"]
-DOMAIN = "entity_transport"
-MULTI_CONF = True
-
-CONF_BROADCAST_ID = "broadcast_id"
-CONF_ENTITY_TRANSPORT_ID = "entity_transport_id"
-
-entity_transport_ns = cg.esphome_ns.namespace("entity_transport")
-EntityTransport = entity_transport_ns.class_("EntityTransport", cg.Component)
-
-_request_remote_sensor_slot = cg.slot_counter("ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT")
-_request_remote_binary_sensor_slot = cg.slot_counter(
-    "ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT"
-)
-
-
-def _advertised_id(conf: ConfigType) -> str:
-    return conf.get(CONF_BROADCAST_ID, conf[CONF_ID].id)
-
-
-def _unique_advertised_ids(entities: list[ConfigType]) -> list[ConfigType]:
-    """A receiver tells entities of one type apart by their advertised ids, so each must be different."""
-    seen: set[str] = set()
-    for index, conf in enumerate(entities):
-        if (advertised := _advertised_id(conf)) in seen:
-            raise cv.Invalid(
-                f"The id '{advertised}' is sent for two entities", path=[index]
-            )
-        seen.add(advertised)
-    return entities
-
-
-def _local_entity(cls: MockObjClass) -> Callable[[Any], Any]:
-    return cv.maybe_simple_value(
-        cv.Schema(
-            {
-                cv.Required(CONF_ID): cv.use_id(cls),
-                cv.Optional(CONF_BROADCAST_ID): cv.All(
-                    cv.validate_id_name, cv.Length(max=255)
-                ),
-            }
-        ),
-        key=CONF_ID,
-    )
-
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(EntityTransport),
-        cv.Required(CONF_PACKET_INTERFACE): cv.use_id(packet_interface.PacketInterface),
-        # Defaults to a periodic resend unless the interface has session and reliability layers
-        cv.Optional(CONF_UPDATE_INTERVAL): cv.All(
-            cv.update_interval, cv.Range(min=cv.TimePeriod(seconds=1))
-        ),
-        # Remote entities lose their state when none arrives for this long
-        cv.Optional(CONF_TIMEOUT): cv.All(
-            cv.positive_time_period_milliseconds,
-            cv.Range(min=cv.TimePeriod(seconds=1)),
-        ),
-        # Entities are numbered with one byte
-        cv.Optional(CONF_SENSORS): cv.All(
-            cv.ensure_list(_local_entity(Sensor)),
-            cv.Length(max=255),
-            _unique_advertised_ids,
-        ),
-        cv.Optional(CONF_BINARY_SENSORS): cv.All(
-            cv.ensure_list(_local_entity(BinarySensor)),
-            cv.Length(max=255),
-            _unique_advertised_ids,
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    """With a session layer, which clears the states when the peer is lost, nothing would refresh an unchanged state."""
-    if CONF_TIMEOUT in config and interface_has_layer(
-        config[CONF_PACKET_INTERFACE], CONF_SESSION
-    ):
-        raise cv.Invalid(
-            f"Not allowed with a '{CONF_SESSION}' layer, or a link that does its job, which already clears the "
-            "states when the other device cannot be reached; unchanged states may never be sent again, so they "
-            "would time out on a working link",
-            path=[CONF_TIMEOUT],
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = cv.All(
-    final_validate_interface(CONF_PACKET_INTERFACE), _final_validate
-)
-
-
-def _validate_remote_id(config: ConfigType) -> ConfigType:
-    if CONF_REMOTE_ID not in config and not config[CONF_ID].is_manual:
-        raise cv.Invalid(f"'{CONF_REMOTE_ID}' is required unless '{CONF_ID}' is given")
-    return config
-
-
-def remote_entity_schema(base_schema: cv.Schema) -> cv.Schema:
-    """Schema for an entity whose state comes from another device."""
-    return cv.All(
-        base_schema.extend(
-            {
-                cv.GenerateID(CONF_ENTITY_TRANSPORT_ID): cv.use_id(EntityTransport),
-                cv.Required(CONF_PROVIDER): cv.valid_name,
-                cv.Optional(CONF_REMOTE_ID): cv.All(
-                    cv.string_strict, cv.Length(min=1, max=255)
-                ),
-            }
-        ),
-        _validate_remote_id,
-    )
-
-
-def _remote_id(config: ConfigType) -> str:
-    return config.get(CONF_REMOTE_ID) or config[CONF_ID].id
-
-
-async def register_remote_sensor(config: ConfigType, var: MockObj) -> None:
-    hub = await cg.get_variable(config[CONF_ENTITY_TRANSPORT_ID])
-    _request_remote_sensor_slot(str(hub))
-    cg.add(hub.add_remote_sensor(config[CONF_PROVIDER], _remote_id(config), var))
-
-
-async def register_remote_binary_sensor(config: ConfigType, var: MockObj) -> None:
-    hub = await cg.get_variable(config[CONF_ENTITY_TRANSPORT_ID])
-    _request_remote_binary_sensor_slot(str(hub))
-    cg.add(hub.add_remote_binary_sensor(config[CONF_PROVIDER], _remote_id(config), var))
-
-
-async def to_code(config: ConfigType) -> None:
-    interface = await cg.get_variable(config[CONF_PACKET_INTERFACE])
-    var = cg.new_Pvariable(config[CONF_ID], interface)
-    await cg.register_component(var, config)
-    if (interval := config.get(CONF_UPDATE_INTERVAL)) is not None:
-        cg.add(var.set_update_interval(interval))
-    if (timeout := config.get(CONF_TIMEOUT)) is not None:
-        cg.add(var.set_remote_timeout(timeout))
-    sensors = config.get(CONF_SENSORS, [])
-    binary_sensors = config.get(CONF_BINARY_SENSORS, [])
-    if count := len(sensors) + len(binary_sensors):
-        cg.add(var.set_entity_count(count))
-    for conf in sensors:
-        sensor = await cg.get_variable(conf[CONF_ID])
-        cg.add(var.add_sensor(_advertised_id(conf), sensor))
-    for conf in binary_sensors:
-        sensor = await cg.get_variable(conf[CONF_ID])
-        cg.add(var.add_binary_sensor(_advertised_id(conf), sensor))

esphome/components/entity_transport/binary_sensor.py

@@ -1,11 +0,0 @@
-from esphome.components import binary_sensor
-from esphome.types import ConfigType
-
-from . import register_remote_binary_sensor, remote_entity_schema
-
-CONFIG_SCHEMA = remote_entity_schema(binary_sensor.binary_sensor_schema())
-
-
-async def to_code(config: ConfigType) -> None:
-    var = await binary_sensor.new_binary_sensor(config)
-    await register_remote_binary_sensor(config, var)

esphome/components/entity_transport/entity_transport.cpp

@@ -1,683 +0,0 @@
-#include "entity_transport.h"
-#include <algorithm>
-#include <cmath>
-#include <cstring>
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-namespace esphome::entity_transport {
-
-using packet_interface::PacketBuffer;
-using packet_interface::PacketMetaData;
-
-ESPHOME_LOG_TAG(TAG, "entity_transport");
-
-// The packet type byte holds the format version in its high nibble
-static constexpr uint8_t FORMAT_VERSION = 1;
-static constexpr uint8_t PACKET_DICTIONARY = 0x11;
-static constexpr uint8_t PACKET_DATA = 0x12;
-static constexpr uint8_t PACKET_REQUEST = 0x13;
-// Entity types, in dictionary sections and data records; 0 is not used
-static constexpr uint8_t TYPE_SENSOR = 1;
-static constexpr uint8_t TYPE_BINARY_SENSOR = 2;
-static constexpr uint8_t MAX_TYPE = 31;
-// Packet type and dictionary id
-static constexpr size_t HEADER_SIZE = 5;
-// A dictionary packet's part byte follows the header: the part's index in bits 0-6, and on the last part, bit 7
-static constexpr uint8_t PART_INDEX_MASK = 0x7F;
-static constexpr uint8_t PART_LAST = 0x80;
-static constexpr uint8_t PART_NONE = 0xFF;  // no dictionary is being received in order
-// A data record starts with a 16-bit tag: the entity's number in bits 0-7, its type in bits 8-12, the payload form in
-// bits 13-14, and with PAYLOAD_NONE, the state in bit 15. Any record can be skipped without knowing its type.
-static constexpr size_t TAG_SIZE = 2;
-static constexpr uint8_t TAG_TYPE_SHIFT = 8;
-static constexpr uint8_t TAG_PAYLOAD_SHIFT = 13;
-static constexpr uint16_t TAG_VALUE_BIT = 0x8000;
-static constexpr uint8_t PAYLOAD_NONE = 0;      // the state is in the tag's value bit
-static constexpr uint8_t PAYLOAD_WORD = 1;      // 4 bytes follow
-static constexpr uint8_t PAYLOAD_LENGTH = 2;    // a length byte follows, then that many bytes
-static constexpr uint8_t PAYLOAD_NO_STATE = 3;  // the entity has no state
-static constexpr size_t WORD_SIZE = 4;
-static constexpr size_t MAX_RECORD_SIZE = TAG_SIZE + WORD_SIZE;
-// A dictionary section starts with the entity type, first number and count
-static constexpr size_t SECTION_HEADER_SIZE = 3;
-static constexpr size_t MAX_STRING_LENGTH = 255;
-static constexpr uint32_t DEFAULT_UPDATE_INTERVAL_MS = 15000;
-static constexpr uint32_t REQUEST_INTERVAL_MS = 5000;
-static constexpr uint32_t RETRY_DELAY_MS = 1000;
-static constexpr uint32_t RETRY_TIMER_ID = 0;
-static constexpr uint32_t TIMEOUT_CHECK_INTERVAL_MS = 1000;
-static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
-// How long the interface may refuse every packet before it is reported
-static constexpr uint32_t REFUSED_WARNING_MS = 60000;
-
-static void put_uint32(uint8_t *buf, uint32_t value) {
-  for (size_t i = 0; i != 4; i++)
-    buf[i] = value >> (i * 8);
-}
-
-// True if the NUL terminated str is the same as the len bytes at data
-static bool matches(const char *str, const char *data, size_t len) {
-  return strlen(str) == len && memcmp(str, data, len) == 0;
-}
-
-struct Record {
-  uint8_t number;
-  uint8_t type;
-  uint8_t payload;
-  bool value;
-  const uint8_t *data;  // what follows the tag
-};
-
-static Record parse_record(std::span<const uint8_t> packet, size_t pos) {
-  uint16_t tag = encode_uint16(packet[pos + 1], packet[pos]);
-  return {static_cast<uint8_t>(tag), static_cast<uint8_t>((tag >> TAG_TYPE_SHIFT) & MAX_TYPE),
-          static_cast<uint8_t>((tag >> TAG_PAYLOAD_SHIFT) & 3), (tag & TAG_VALUE_BIT) != 0,
-          packet.data() + pos + TAG_SIZE};
-}
-
-// The size of the data record at pos, or 0 if it does not fit in the packet
-static size_t record_size(std::span<const uint8_t> packet, size_t pos) {
-  if (pos + TAG_SIZE > packet.size())
-    return 0;
-  size_t size = TAG_SIZE;
-  uint8_t payload = parse_record(packet, pos).payload;
-  if (payload == PAYLOAD_WORD) {
-    size += WORD_SIZE;
-  } else if (payload == PAYLOAD_LENGTH) {
-    if (pos + TAG_SIZE == packet.size())
-      return 0;
-    size += 1 + packet[pos + TAG_SIZE];
-  }
-  return pos + size <= packet.size() ? size : 0;
-}
-
-// Checks every record of a data packet, so that a damaged or forged packet changes no state at all
-static bool data_well_formed(std::span<const uint8_t> packet) {
-  for (size_t pos = HEADER_SIZE; pos != packet.size();) {
-    size_t size = record_size(packet, pos);
-    if (size == 0)
-      return false;
-    Record record = parse_record(packet, pos);
-    if (record.type == 0 || (record.value && record.payload != PAYLOAD_NONE))
-      return false;
-    // Types this device knows must use their own payload form; others are skipped
-    if (record.type == TYPE_SENSOR && record.payload != PAYLOAD_WORD && record.payload != PAYLOAD_NO_STATE)
-      return false;
-    if (record.type == TYPE_BINARY_SENSOR && record.payload != PAYLOAD_NONE && record.payload != PAYLOAD_NO_STATE)
-      return false;
-    pos += size;
-  }
-  return true;
-}
-
-// Checks the device name and every section of a dictionary packet before anything is learnt from it
-static bool dictionary_well_formed(std::span<const uint8_t> packet) {
-  size_t pos = HEADER_SIZE + 1;
-  if (pos >= packet.size())
-    return false;
-  pos += 1 + packet[pos];
-  if (pos > packet.size())
-    return false;
-  while (pos != packet.size()) {
-    if (pos + SECTION_HEADER_SIZE > packet.size())
-      return false;
-    uint8_t type = packet[pos];
-    size_t first = packet[pos + 1];
-    size_t count = packet[pos + 2];
-    pos += SECTION_HEADER_SIZE;
-    // Numbers are one byte, and a data record can name types up to MAX_TYPE only
-    if (type == 0 || type > MAX_TYPE || count == 0 || first + count > 256)
-      return false;
-    for (size_t i = 0; i != count; i++) {
-      if (pos == packet.size())
-        return false;
-      pos += 1 + packet[pos];
-      if (pos > packet.size())
-        return false;
-    }
-  }
-  return true;
-}
-
-void EntityTransport::setup() {
-  this->interface_ = this->interface_->top();
-  this->max_packet_size_ = this->interface_->get_max_packet_size();
-  const auto &name = App.get_name();
-  size_t longest_id = 0;
-  for (const auto &entity : this->entities_)
-    longest_id = std::max(longest_id, strlen(entity.id));
-  // A dictionary packet must hold the device name and any one id, which also leaves room for a data record
-  if (name.size() > MAX_STRING_LENGTH || longest_id > MAX_STRING_LENGTH ||
-      HEADER_SIZE + 2 + name.size() + SECTION_HEADER_SIZE + 1 + longest_id > this->max_packet_size_) {
-    this->mark_failed(LOG_STR("max_packet_size too small for the device name and entity ids"));
-    return;
-  }
-  RAMAllocator<uint8_t> allocator;
-  this->buffer_ = allocator.allocate(this->max_packet_size_);
-  if (this->buffer_ == nullptr) {
-    this->mark_failed(LOG_STR("Not enough memory for the packet buffer"));
-    return;
-  }
-  // The dictionary id changes when the device name or any entity changes
-  uint32_t hash = fnv1a_hash(name.c_str());
-  for (const auto &entity : this->entities_) {
-    hash = fnv1a_hash_extend(hash, entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR);
-    hash = fnv1a_hash_extend(hash, entity.id);
-  }
-  this->dictionary_id_ = hash;
-
-  // [&entity] is safe: FixedVector never reallocates, and the parent pointer keeps the capture to one pointer
-  for (auto &entity : this->entities_) {
-#ifdef USE_SENSOR
-    if (entity.is_sensor) {
-      static_cast<sensor::Sensor *>(entity.entity)->add_on_state_callback([&entity](float) {
-        entity.parent->mark_updated_(entity);
-      });
-    }
-#endif
-#ifdef USE_BINARY_SENSOR
-    if (!entity.is_sensor) {
-      // The full state callback also fires for the first state
-      static_cast<binary_sensor::BinarySensor *>(entity.entity)
-          ->add_full_state_callback(
-              [&entity](optional<bool>, optional<bool>) { entity.parent->mark_updated_(entity); });
-    }
-#endif
-  }
-  this->interface_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &) { this->receive_(data); });
-
-  bool session = this->interface_->has_capability(packet_interface::CAPABILITY_SESSION);
-  if (session)
-    this->interface_->add_on_session_state_callback([this](bool connected) { this->on_session_(connected); });
-  // Without a session and reliable delivery, a lost dictionary or state is only replaced by a periodic resend
-  if (this->update_interval_ms_ == 0) {
-    this->update_interval_ms_ = session && this->interface_->has_capability(packet_interface::CAPABILITY_RELIABILITY)
-                                    ? SCHEDULER_DONT_RUN
-                                    : DEFAULT_UPDATE_INTERVAL_MS;
-  }
-  if (this->update_interval_ms_ != SCHEDULER_DONT_RUN)
-    this->set_interval(this->update_interval_ms_, [this] { this->send_all_(); });
-  if (this->remote_timeout_ms_ != 0)
-    this->set_interval(TIMEOUT_CHECK_INTERVAL_MS, [this] { this->clear_remote_states_(true); });
-  this->send_all_();
-}
-
-void EntityTransport::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Entity Transport:\n"
-                "  Packet Interface: %s\n"
-                "  Max Packet Size: %zu\n"
-                "  Encryption: %s\n"
-                "  Reliability: %s\n"
-                "  Session: %s\n"
-                "  Dictionary ID: %08" PRIX32,
-                this->interface_->get_name(), this->max_packet_size_,
-                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_ENCRYPTION)),
-                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_RELIABILITY)),
-                YESNO(this->interface_->has_capability(packet_interface::CAPABILITY_SESSION)), this->dictionary_id_);
-  if (this->update_interval_ms_ == SCHEDULER_DONT_RUN) {
-    ESP_LOGCONFIG(TAG, "  Update Interval: never");
-  } else {
-    ESP_LOGCONFIG(TAG, "  Update Interval: %" PRIu32 "ms", this->update_interval_ms_);
-  }
-  if (this->remote_timeout_ms_ != 0) {
-    ESP_LOGCONFIG(TAG, "  Remote Timeout: %" PRIu32 "ms", this->remote_timeout_ms_);
-  }
-  for (const auto &entity : this->entities_) {
-    ESP_LOGCONFIG(TAG, "  %s %u: %s", entity.is_sensor ? LOG_STR_LITERAL("Sensor") : LOG_STR_LITERAL("Binary Sensor"),
-                  entity.number, entity.id);
-  }
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  for (const auto &remote : this->remote_sensors_) {
-    ESP_LOGCONFIG(TAG, "  Remote Sensor: %s from %s", remote.remote_id, remote.provider);
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  for (const auto &remote : this->remote_binary_sensors_) {
-    ESP_LOGCONFIG(TAG, "  Remote Binary Sensor: %s from %s", remote.remote_id, remote.provider);
-  }
-#endif
-}
-
-void EntityTransport::send_all_() {
-  this->dictionary_pending_ = true;
-  this->dictionary_next_ = 0;
-  this->dictionary_part_ = 0;
-  for (auto &entity : this->entities_)
-    entity.updated = true;
-  this->enable_loop();
-}
-
-void EntityTransport::mark_updated_(LocalEntity &entity) {
-  entity.updated = true;
-  this->enable_loop();
-}
-
-void EntityTransport::loop() {
-  this->disable_loop();
-  // States are only sent once the dictionary that names them has been accepted
-  if ((this->dictionary_pending_ && !this->send_dictionary_()) || !this->send_updated_()) {
-    this->sending_refused_();
-    this->set_timeout(RETRY_TIMER_ID, RETRY_DELAY_MS, [this] { this->enable_loop(); });
-    return;
-  }
-  this->refusing_ = false;
-  if (this->status_has_warning()) {
-    ESP_LOGI(TAG, "Packets are accepted again");
-    this->status_clear_warning();
-  }
-}
-
-// A link that is down or full refuses packets for a while; one that refuses them for long sends nothing at all
-void EntityTransport::sending_refused_() {
-  uint32_t now = App.get_loop_component_start_time();
-  if (!this->refusing_) {
-    this->refusing_ = true;
-    this->refused_since_ms_ = now;
-    return;
-  }
-  if (!this->status_has_warning() && now - this->refused_since_ms_ >= REFUSED_WARNING_MS) {
-    ESP_LOGW(TAG, "The packet interface has accepted no packets for %" PRIu32 "s, so no states are sent",
-             (now - this->refused_since_ms_) / 1000);
-    this->status_set_warning();
-  }
-}
-
-size_t EntityTransport::write_header_(uint8_t type) const {
-  this->buffer_[0] = type;
-  put_uint32(this->buffer_ + 1, this->dictionary_id_);
-  return HEADER_SIZE;
-}
-
-bool EntityTransport::send_dictionary_() {
-  uint8_t *buf = this->buffer_;
-  const auto &name = App.get_name();
-  size_t header = this->write_header_(PACKET_DICTIONARY);
-  size_t part_offset = header++;
-  buf[header++] = name.size();
-  memcpy(buf + header, name.c_str(), name.size());
-  header += name.size();
-  size_t length = header;
-  size_t count_offset = 0;
-  uint8_t section_type = 0;  // none
-  // A dictionary in several packets resumes after the last packet accepted, so a refused one does not resend the rest
-  for (size_t i = this->dictionary_next_; i != this->entities_.size(); i++) {
-    const auto &entity = this->entities_[i];
-    uint8_t type = entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR;
-    size_t id_length = strlen(entity.id);
-    bool new_section = type != section_type;
-    if (length + (new_section ? SECTION_HEADER_SIZE : 0) + 1 + id_length > this->max_packet_size_) {
-      buf[part_offset] = this->dictionary_part_ & PART_INDEX_MASK;
-      if (!this->interface_->send_to_interface(PacketBuffer(buf, length), {})) {
-        ESP_LOGV(TAG, "Dictionary packet of %zu bytes not accepted, will retry", length);
-        return false;
-      }
-      this->dictionary_next_ = i;
-      this->dictionary_part_++;
-      length = header;
-      new_section = true;
-    }
-    if (new_section) {
-      buf[length++] = type;
-      buf[length++] = entity.number;
-      count_offset = length;
-      buf[length++] = 0;
-      section_type = type;
-    }
-    buf[count_offset]++;
-    buf[length++] = id_length;
-    memcpy(buf + length, entity.id, id_length);
-    length += id_length;
-  }
-  if (length != header) {
-    buf[part_offset] = (this->dictionary_part_ & PART_INDEX_MASK) | PART_LAST;
-    if (!this->interface_->send_to_interface(PacketBuffer(buf, length), {})) {
-      ESP_LOGV(TAG, "Dictionary packet of %zu bytes not accepted, will retry", length);
-      return false;
-    }
-  }
-  this->dictionary_pending_ = false;
-  this->dictionary_next_ = 0;
-  this->dictionary_part_ = 0;
-  return true;
-}
-
-// Writes the entity's data record, and returns its size
-size_t EntityTransport::write_record_(const LocalEntity &entity, uint8_t *record) const {
-  uint8_t type = entity.is_sensor ? TYPE_SENSOR : TYPE_BINARY_SENSOR;
-  uint8_t payload = PAYLOAD_NO_STATE;
-  bool value = false;
-  size_t size = TAG_SIZE;
-#ifdef USE_SENSOR
-  if (entity.is_sensor) {
-    float state = static_cast<sensor::Sensor *>(entity.entity)->get_state();
-    if (!std::isnan(state)) {
-      payload = PAYLOAD_WORD;
-      uint32_t bits;
-      memcpy(&bits, &state, sizeof(bits));
-      put_uint32(record + TAG_SIZE, bits);
-      size += WORD_SIZE;
-    }
-  }
-#endif
-#ifdef USE_BINARY_SENSOR
-  if (!entity.is_sensor) {
-    auto *sensor = static_cast<binary_sensor::BinarySensor *>(entity.entity);
-    if (sensor->has_state()) {
-      payload = PAYLOAD_NONE;
-      value = sensor->state;
-    }
-  }
-#endif
-  uint16_t tag =
-      entity.number | (type << TAG_TYPE_SHIFT) | (payload << TAG_PAYLOAD_SHIFT) | (value ? TAG_VALUE_BIT : 0);
-  record[0] = tag;
-  record[1] = tag >> 8;
-  return size;
-}
-
-// Sends every updated entity, in as few packets as fit; returns false if a packet was refused
-bool EntityTransport::send_updated_() {
-  size_t length = this->write_header_(PACKET_DATA);
-  size_t first = 0;
-  for (size_t i = 0; i != this->entities_.size(); i++) {
-    auto &entity = this->entities_[i];
-    if (!entity.updated)
-      continue;
-    uint8_t record[MAX_RECORD_SIZE];
-    size_t size = this->write_record_(entity, record);
-    if (length + size > this->max_packet_size_) {
-      if (!this->flush_(length, first, i))
-        return false;
-      length = HEADER_SIZE;
-      first = i;
-    }
-    memcpy(this->buffer_ + length, record, size);
-    length += size;
-  }
-  return this->flush_(length, first, this->entities_.size());
-}
-
-// Sends the packet holding the updated entities from first up to last, and clears their flags if it was accepted
-bool EntityTransport::flush_(size_t length, size_t first, size_t last) {
-  if (length == HEADER_SIZE)
-    return true;
-  if (!this->interface_->send_to_interface(PacketBuffer(this->buffer_, length), {})) {
-    ESP_LOGV(TAG, "Packet of %zu bytes not accepted, will retry", length);
-    return false;
-  }
-  for (size_t i = first; i != last; i++)
-    this->entities_[i].updated = false;
-  return true;
-}
-
-void EntityTransport::receive_(const PacketBuffer &data) {
-  // Packet interface layers deliver packets in one piece
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "Packet split across buffers is not supported");
-    return;
-  }
-  auto packet = data.as_span();
-  if (packet.size() < HEADER_SIZE) {
-    if (this->warning_due_()) {
-      ESP_LOGW(TAG, "Packet of %zu bytes is too short", packet.size());
-    }
-    return;
-  }
-  if (packet[0] >> 4 != FORMAT_VERSION) {
-    if (this->warning_due_()) {
-      ESP_LOGW(TAG, "Packet format version %u not supported; the sender may run another ESPHome version",
-               packet[0] >> 4);
-    }
-    return;
-  }
-  uint32_t dictionary_id = encode_uint32(packet[4], packet[3], packet[2], packet[1]);
-  if (dictionary_id == this->dictionary_id_) {
-    // Either a request for our dictionary, or our own packet heard on a broadcast channel
-    if (packet[0] == PACKET_REQUEST && packet.size() == HEADER_SIZE) {
-      ESP_LOGD(TAG, "Dictionary requested");
-      this->send_all_();
-    }
-    return;
-  }
-  if (packet[0] == PACKET_DICTIONARY) {
-    this->receive_dictionary_(packet, dictionary_id);
-  } else if (packet[0] == PACKET_DATA) {
-    this->receive_data_(packet, dictionary_id);
-  } else if (packet[0] != PACKET_REQUEST) {
-    ESP_LOGV(TAG, "Unknown packet type 0x%02X", packet[0]);
-  }
-}
-
-void EntityTransport::receive_dictionary_(std::span<const uint8_t> packet, uint32_t dictionary_id) {
-  if (!dictionary_well_formed(packet)) {
-    if (this->warning_due_()) {
-      ESP_LOGW(TAG, "Dictionary packet of %zu bytes is malformed", packet.size());
-    }
-    return;
-  }
-  size_t pos = HEADER_SIZE;
-  uint8_t part = packet[pos++];
-  uint8_t index = part & PART_INDEX_MASK;
-  // The dictionary is complete, and need not be asked for again, once its last part follows all the others in order
-  bool in_order = index == 0 || (this->rx_dictionary_id_ == dictionary_id && index == this->rx_next_part_);
-  this->rx_dictionary_id_ = dictionary_id;
-  this->rx_next_part_ = in_order ? (index + 1) & PART_INDEX_MASK : PART_NONE;
-  bool completed = in_order && (part & PART_LAST) != 0;
-  bool first_time = completed && !this->dictionary_seen_(dictionary_id);
-  if (first_time) {
-    this->seen_dictionaries_[this->seen_next_] = dictionary_id;
-    this->seen_next_ = (this->seen_next_ + 1) % this->seen_dictionaries_.size();
-  }
-  size_t provider_length = packet[pos++];
-  const auto *provider = reinterpret_cast<const char *>(packet.data() + pos);
-  pos += provider_length;
-  while (pos != packet.size()) {
-    uint8_t type = packet[pos];
-    uint8_t number = packet[pos + 1];
-    uint8_t count = packet[pos + 2];
-    pos += SECTION_HEADER_SIZE;
-    for (uint8_t i = 0; i != count; i++) {
-      size_t id_length = packet[pos++];
-      this->learn_(provider, provider_length, type, number + i, reinterpret_cast<const char *>(packet.data() + pos),
-                   id_length, dictionary_id);
-      pos += id_length;
-    }
-  }
-  // A provider may go back to a dictionary already seen, so every complete one is checked
-  if (completed)
-    this->forget_unnamed_(provider, provider_length, dictionary_id, first_time);
-}
-
-void EntityTransport::forget_unnamed_(const char *provider, size_t provider_length, uint32_t dictionary_id,
-                                      bool first_time) {
-  // A remote entity that its provider's whole dictionary does not name would otherwise keep no or a stale state
-  // silently
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  for (auto &remote : this->remote_sensors_) {
-    if (!matches(remote.provider, provider, provider_length) || (remote.known && remote.dictionary_id == dictionary_id))
-      continue;
-    if (remote.known || first_time) {
-      ESP_LOGW(TAG, "'%s' does not send '%s'", remote.provider, remote.remote_id);
-    }
-    remote.known = false;
-    if (remote.has_state) {
-      remote.has_state = false;
-      remote.entity->publish_state(NAN);
-    }
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  for (auto &remote : this->remote_binary_sensors_) {
-    if (!matches(remote.provider, provider, provider_length) || (remote.known && remote.dictionary_id == dictionary_id))
-      continue;
-    if (remote.known || first_time) {
-      ESP_LOGW(TAG, "'%s' does not send '%s'", remote.provider, remote.remote_id);
-    }
-    remote.known = false;
-    if (remote.has_state) {
-      remote.has_state = false;
-      remote.entity->invalidate_state();
-    }
-  }
-#endif
-}
-
-void EntityTransport::learn_(const char *provider, size_t provider_length, uint8_t type, uint8_t number, const char *id,
-                             size_t id_length, uint32_t dictionary_id) {
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  if (type == TYPE_SENSOR) {
-    for (auto &remote : this->remote_sensors_) {
-      if (matches(remote.provider, provider, provider_length) && matches(remote.remote_id, id, id_length)) {
-        remote.dictionary_id = dictionary_id;
-        remote.number = number;
-        remote.known = true;
-      }
-    }
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  if (type == TYPE_BINARY_SENSOR) {
-    for (auto &remote : this->remote_binary_sensors_) {
-      if (matches(remote.provider, provider, provider_length) && matches(remote.remote_id, id, id_length)) {
-        remote.dictionary_id = dictionary_id;
-        remote.number = number;
-        remote.known = true;
-      }
-    }
-  }
-#endif
-}
-
-bool EntityTransport::dictionary_seen_(uint32_t dictionary_id) const {
-  return std::find(this->seen_dictionaries_.begin(), this->seen_dictionaries_.end(), dictionary_id) !=
-         this->seen_dictionaries_.end();
-}
-
-void EntityTransport::receive_data_(std::span<const uint8_t> packet, uint32_t dictionary_id) {
-  bool known = false;
-  bool has_remotes = false;
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  for (const auto &remote : this->remote_sensors_) {
-    known |= remote.known && remote.dictionary_id == dictionary_id;
-    has_remotes = true;
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  for (const auto &remote : this->remote_binary_sensors_) {
-    known |= remote.known && remote.dictionary_id == dictionary_id;
-    has_remotes = true;
-  }
-#endif
-  if (!has_remotes)
-    return;
-  // Checked first, so a damaged packet does not make the provider resend everything
-  if (!data_well_formed(packet)) {
-    if (this->warning_due_()) {
-      ESP_LOGW(TAG, "Data packet of %zu bytes is malformed", packet.size());
-    }
-    return;
-  }
-  // A dictionary not yet received in full may name our entities, or be a provider's new one; one received in full
-  // named all of them it could, so asking again would only make that provider resend everything
-  if (!this->dictionary_seen_(dictionary_id))
-    this->request_dictionary_(dictionary_id);
-  if (!known)
-    return;
-  [[maybe_unused]] uint32_t now = App.get_loop_component_start_time();
-  for (size_t pos = HEADER_SIZE; pos != packet.size(); pos += record_size(packet, pos)) {
-    [[maybe_unused]] Record record = parse_record(packet, pos);
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-    if (record.type == TYPE_SENSOR) {
-      float value = NAN;
-      if (record.payload == PAYLOAD_WORD) {
-        uint32_t bits = encode_uint32(record.data[3], record.data[2], record.data[1], record.data[0]);
-        memcpy(&value, &bits, sizeof(value));
-      }
-      for (auto &remote : this->remote_sensors_) {
-        if (remote.known && remote.dictionary_id == dictionary_id && remote.number == record.number) {
-          remote.last_state_ms = now;
-          remote.has_state = true;
-          remote.entity->publish_state(value);
-        }
-      }
-    }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-    if (record.type == TYPE_BINARY_SENSOR) {
-      for (auto &remote : this->remote_binary_sensors_) {
-        if (!remote.known || remote.dictionary_id != dictionary_id || remote.number != record.number)
-          continue;
-        remote.last_state_ms = now;
-        remote.has_state = true;
-        if (record.payload == PAYLOAD_NO_STATE) {
-          remote.entity->invalidate_state();
-        } else {
-          remote.entity->publish_state(record.value);
-        }
-      }
-    }
-#endif
-  }
-}
-
-void EntityTransport::request_dictionary_(uint32_t dictionary_id) {
-  uint32_t now = App.get_loop_component_start_time();
-  if (this->request_sent_ && now - this->last_request_ms_ < REQUEST_INTERVAL_MS)
-    return;
-  uint8_t packet[HEADER_SIZE] = {PACKET_REQUEST};
-  put_uint32(packet + 1, dictionary_id);
-  // A refused request is tried again with the next data packet under that dictionary id
-  if (!this->interface_->send_to_interface(PacketBuffer(packet, sizeof(packet)), {})) {
-    ESP_LOGV(TAG, "Request for dictionary %08" PRIX32 " not accepted", dictionary_id);
-    return;
-  }
-  this->request_sent_ = true;
-  this->last_request_ms_ = now;
-  ESP_LOGD(TAG, "Requested dictionary %08" PRIX32, dictionary_id);
-}
-
-// Dropped packets point to a device with other firmware or a fault, and may arrive steadily, so warn only now and then
-bool EntityTransport::warning_due_() {
-  uint32_t now = App.get_loop_component_start_time();
-  if (this->warned_ && now - this->last_warning_ms_ < WARNING_INTERVAL_MS)
-    return false;
-  this->warned_ = true;
-  this->last_warning_ms_ = now;
-  return true;
-}
-
-// A newly connected or restarted peer needs the dictionary and every state; while it is lost, its entities have no
-// state
-void EntityTransport::on_session_(bool connected) {
-  if (connected) {
-    this->send_all_();
-    return;
-  }
-  this->clear_remote_states_(false);
-}
-
-// Clears the state of every remote entity, or with timed_out_only, of those whose state is older than the timeout
-void EntityTransport::clear_remote_states_(bool timed_out_only) {
-  [[maybe_unused]] uint32_t now = App.get_loop_component_start_time();
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  for (auto &remote : this->remote_sensors_) {
-    if (timed_out_only && (!remote.has_state || now - remote.last_state_ms <= this->remote_timeout_ms_))
-      continue;
-    remote.has_state = false;
-    remote.entity->publish_state(NAN);
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  for (auto &remote : this->remote_binary_sensors_) {
-    if (timed_out_only && (!remote.has_state || now - remote.last_state_ms <= this->remote_timeout_ms_))
-      continue;
-    remote.has_state = false;
-    remote.entity->invalidate_state();
-  }
-#endif
-}
-
-}  // namespace esphome::entity_transport

esphome/components/entity_transport/entity_transport.h

@@ -1,171 +0,0 @@
-#pragma once
-
-#include <array>
-#include <span>
-
-#include "esphome/components/packet_interface/packet_interface.h"
-#include "esphome/core/component.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/entity_base.h"
-#include "esphome/core/helpers.h"
-#ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
-#endif
-#ifdef USE_BINARY_SENSOR
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#endif
-
-namespace esphome::entity_transport {
-
-/**
- * Sends the states of local sensors and binary sensors over a packet interface, and publishes the states received
- * from other devices to remote entities.
- *
- * Each device numbers its sensors and its binary sensors from 0, and sends a dictionary that gives the id for each
- * number. Data packets then refer to an entity by its number. Every packet carries the sender's dictionary id, a hash
- * of its device name and dictionary, so that a receiver knows which device sent it and which dictionary applies.
- * All values are little endian.
- *
- * Dictionary packet:
- * - type: 1 byte, PACKET_DICTIONARY;
- * - dictionary id: 4 bytes;
- * - part: 1 byte, the packet's index in the dictionary in bits 0-6, counting from 0 and wrapping, and bit 7 set on
- *   the last packet;
- * - sender's device name: length (1 byte), then the name;
- * - one or more sections, each: entity type (1 byte), first number (1 byte), count (1 byte), then for each entity
- *   its id: length (1 byte), then the id.
- *
- * Data packet:
- * - type: 1 byte, PACKET_DATA;
- * - dictionary id: 4 bytes;
- * - records, to the end, each a 16-bit tag, then its payload. The tag holds the entity's number in bits 0-7, its type
- *   in bits 8-12, and the payload form in bits 13-14: none, with the state in bit 15 (binary sensors); 4 bytes (a
- *   sensor's float); a length byte, then that many bytes; or no state, with no payload. The form gives the record's
- *   size, so a receiver skips records of types it does not know.
- *
- * Every packet is checked in full before anything in it is used, so a damaged or forged packet changes no state.
- *
- * Dictionary request packet, sent by a device that receives data with a dictionary id it has not received in full,
- * with every part in order:
- * - type: 1 byte, PACKET_REQUEST;
- * - the dictionary id wanted: 4 bytes.
- *
- * Changed states are sent from loop(). The dictionary and all states are sent at boot, when a session layer reports
- * the peer connected, when the dictionary is requested, and every update interval. Unless the interface has both a
- * session and a reliability layer, the update interval defaults to DEFAULT_UPDATE_INTERVAL_MS. When the interface
- * refuses a packet, sending is tried again after a delay, and a warning is set once it has refused every packet for a
- * minute. With a remote timeout, a remote entity loses its state when
- * none arrives for it within the timeout.
- */
-class EntityTransport : public Component {
- public:
-  explicit EntityTransport(packet_interface::PacketInterface *interface) : interface_(interface) {}
-
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-
-  /// 0 chooses the default for the interface's layers; SCHEDULER_DONT_RUN never resends.
-  void set_update_interval(uint32_t interval_ms) { this->update_interval_ms_ = interval_ms; }
-  /// Remote entities lose their state when none arrives for this long; 0 keeps the last state.
-  void set_remote_timeout(uint32_t timeout_ms) { this->remote_timeout_ms_ = timeout_ms; }
-  void set_entity_count(size_t count) { this->entities_.init(count); }
-  // Sensors must be added before binary sensors, so that data packets hold sensor records first
-#ifdef USE_SENSOR
-  void add_sensor(const char *id, sensor::Sensor *sensor) {
-    this->entities_.push_back({sensor, id, this, this->sensor_count_++, true, true});
-  }
-#endif
-#ifdef USE_BINARY_SENSOR
-  void add_binary_sensor(const char *id, binary_sensor::BinarySensor *sensor) {
-    this->entities_.push_back({sensor, id, this, this->binary_sensor_count_++, false, true});
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  void add_remote_sensor(const char *provider, const char *remote_id, sensor::Sensor *sensor) {
-    this->remote_sensors_.push_back({provider, remote_id, sensor});
-  }
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  void add_remote_binary_sensor(const char *provider, const char *remote_id, binary_sensor::BinarySensor *sensor) {
-    this->remote_binary_sensors_.push_back({provider, remote_id, sensor});
-  }
-#endif
-
- protected:
-  struct LocalEntity {
-    EntityBase *entity;  // a sensor::Sensor or a binary_sensor::BinarySensor, as is_sensor says
-    const char *id;
-    EntityTransport *parent;
-    uint8_t number;
-    bool is_sensor;
-    bool updated;
-  };
-  template<typename T> struct RemoteEntity {
-    const char *provider;
-    const char *remote_id;
-    T *entity;
-    uint32_t dictionary_id{0};  // learnt from the provider's dictionary
-    uint32_t last_state_ms{0};
-    uint8_t number{0};
-    bool known{false};
-    bool has_state{false};  // a state arrived, and has not yet timed out
-  };
-
-  void send_all_();
-  void mark_updated_(LocalEntity &entity);
-  bool send_dictionary_();
-  bool send_updated_();
-  size_t write_record_(const LocalEntity &entity, uint8_t *record) const;
-  bool flush_(size_t length, size_t first, size_t last);
-  size_t write_header_(uint8_t type) const;
-  void receive_(const packet_interface::PacketBuffer &data);
-  void receive_dictionary_(std::span<const uint8_t> packet, uint32_t dictionary_id);
-  void receive_data_(std::span<const uint8_t> packet, uint32_t dictionary_id);
-  void learn_(const char *provider, size_t provider_length, uint8_t type, uint8_t number, const char *id,
-              size_t id_length, uint32_t dictionary_id);
-  void request_dictionary_(uint32_t dictionary_id);
-  bool dictionary_seen_(uint32_t dictionary_id) const;
-  /// Clears each remote entity of \p provider that its complete dictionary does not name, warning if the entity was
-  /// known or the dictionary is \p first_time seen, so a resent dictionary does not repeat the warning.
-  void forget_unnamed_(const char *provider, size_t provider_length, uint32_t dictionary_id, bool first_time);
-  bool warning_due_();
-  void sending_refused_();
-  void on_session_(bool connected);
-  void clear_remote_states_(bool timed_out_only);
-
-  packet_interface::PacketInterface *interface_;
-  FixedVector<LocalEntity> entities_;
-#ifdef ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT
-  StaticVector<RemoteEntity<sensor::Sensor>, ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT> remote_sensors_;
-#endif
-#ifdef ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT
-  StaticVector<RemoteEntity<binary_sensor::BinarySensor>, ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT>
-      remote_binary_sensors_;
-#endif
-  // Packets are built here, allocated in setup()
-  uint8_t *buffer_{nullptr};
-  size_t max_packet_size_{0};
-  uint32_t update_interval_ms_{0};
-  uint32_t remote_timeout_ms_{0};
-  uint32_t dictionary_id_{0};
-  uint32_t last_request_ms_{0};
-  uint32_t last_warning_ms_{0};
-  uint32_t refused_since_ms_{0};  // when the interface began refusing every packet
-  uint32_t rx_dictionary_id_{0};  // the dictionary whose parts are arriving
-  // The last dictionary ids received in full, so a provider whose dictionary names none of our entities is not asked
-  // again
-  std::array<uint32_t, 8> seen_dictionaries_{};
-  uint8_t seen_next_{0};
-  uint8_t rx_next_part_{0};     // the index of its next part, or PART_NONE if one was missed
-  uint8_t dictionary_part_{0};  // the index of the next dictionary packet to send
-  uint8_t sensor_count_{0};
-  uint8_t binary_sensor_count_{0};
-  size_t dictionary_next_{0};  // the first entity of the next dictionary packet to send
-  bool dictionary_pending_{true};
-  bool request_sent_{false};
-  bool warned_{false};
-  bool refusing_{false};
-};
-
-}  // namespace esphome::entity_transport

esphome/components/entity_transport/sensor.py

@@ -1,11 +0,0 @@
-from esphome.components import sensor
-from esphome.types import ConfigType
-
-from . import register_remote_sensor, remote_entity_schema
-
-CONFIG_SCHEMA = remote_entity_schema(sensor.sensor_schema())
-
-
-async def to_code(config: ConfigType) -> None:
-    var = await sensor.new_sensor(config)
-    await register_remote_sensor(config, var)

esphome/components/epaper_spi/display.py

@@ -15,7 +15,6 @@ from esphome.components.mipi import (
 import esphome.config_validation as cv
 from esphome.config_validation import update_interval
 from esphome.const import (
-    CONF_AUTO_CLEAR_ENABLED,
     CONF_BUSY_PIN,
     CONF_CS_PIN,
     CONF_DATA_RATE,
@@ -189,10 +188,7 @@ def customise_schema(config):
         height,
         has_hardware_rotation=True,
         byte_order=cv.UNDEFINED,
-        has_writer=config.get(CONF_AUTO_CLEAR_ENABLED) is True
-        or config.get(CONF_PAGES) is not None
-        or config.get(CONF_LAMBDA) is not None
-        or config.get(CONF_SHOW_TEST_CARD) is True,
+        has_writer=display.config_has_writer(config),
         rotation=config.get(CONF_ROTATION, 0),
         draw_rounding=0,
     )

esphome/components/epaper_spi/epaper_spi.cpp

@@ -1,4 +1,5 @@
 #include "epaper_spi.h"
+#include "esphome/components/display/init_sequence.h"
 #include <cinttypes>
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
@@ -315,26 +316,18 @@ void EPaperBase::start_data_() {
 void EPaperBase::on_safe_shutdown() { this->deep_sleep(); }
 
 void EPaperBase::send_init_sequence_(const uint8_t *sequence, size_t length) {
-  size_t index = 0;
-
-  while (index != length) {
-    if (length - index < 2) {
+  display::InitSequenceReader reader(sequence, length);
+  display::InitSequenceEntry entry;
+  while (auto step = reader.next(entry)) {
+    if (step == display::INIT_SEQUENCE_STEP_MALFORMED) {
       this->mark_failed(LOG_STR("Malformed init sequence"));
       return;
     }
-    const uint8_t cmd = sequence[index++];
-    if (const uint8_t x = sequence[index++]; x == DELAY_FLAG) {
-      ESP_LOGV(TAG, "Delay %dms", cmd);
-      delay(cmd);
+    if (step == display::INIT_SEQUENCE_STEP_DELAY) {
+      ESP_LOGV(TAG, "Delay %dms", entry.value);
+      delay(entry.value);
     } else {
-      const uint8_t num_args = x & 0x7F;
-      if (length - index < num_args) {
-        ESP_LOGE(TAG, "Malformed init sequence, cmd = %X, num_args = %u", cmd, num_args);
-        this->mark_failed();
-        return;
-      }
-      this->cmd_data(cmd, sequence + index, num_args);
-      index += num_args;
+      this->cmd_data(entry.value, entry.args, entry.count);
     }
   }
 }

esphome/components/epaper_spi/epaper_spi.h

@@ -34,7 +34,6 @@ static constexpr uint32_t MAX_TRANSFER_TIME = 10;  // Transfer in 10ms blocks to
 static constexpr size_t MAX_TRANSFER_SIZE = 128;
 // Longer busy waits are the waveform or a stuck pin, and are polled at the normal loop pace
 static constexpr uint32_t FAST_BUSY_POLL_MS = 50;
-static constexpr uint8_t DELAY_FLAG = 0xFF;
 
 class EPaperBase : public Display,
                    public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,

esphome/components/espnow/espnow_component.cpp

@@ -24,7 +24,7 @@ ESPHOME_LOG_TAG(TAG, "espnow");
 
 ESPNowComponent *global_esp_now = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-const LogString *espnow_error_to_str(esp_err_t error) {
+static const LogString *espnow_error_to_str(esp_err_t error) {
   switch (error) {
     case ESP_ERR_ESPNOW_FAILED:
       return LOG_STR("ESPNow is in fail mode");

esphome/components/espnow/espnow_component.h

@@ -25,9 +25,6 @@ namespace esphome::espnow {
 
 using peer_address_t = std::array<uint8_t, ESP_NOW_ETH_ALEN>;
 
-/// A short description of an ESP-NOW error code, for logging.
-const LogString *espnow_error_to_str(esp_err_t error);
-
 enum class ESPNowTriggers : uint8_t {
   TRIGGER_NONE = 0,
   ON_NEW_PEER = 1,
@@ -126,7 +123,6 @@ class ESPNowComponent final : public Component {
   uint8_t get_wifi_channel();
 
   void set_auto_add_peer(bool value) { this->auto_add_peer_ = value; }
-  bool get_auto_add_peer() const { return this->auto_add_peer_; }
 
 #if defined(USE_WIFI) && defined(USE_WIFI_CONNECT_STATE_LISTENERS)
   // WiFiConnectStateListener interface: refresh the cached channel after each (re)connect

esphome/components/espnow/packet_interface/__init__.py

@@ -1,90 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import packet_interface
-from esphome.components.packet_interface import (
-    CONF_MAX_PACKET_SIZE,
-    new_packet_interface,
-    packet_interface_schema,
-)
-from esphome.components.packet_interface.layers import (
-    CONF_ADDRESSING,
-    check_broadcast_link,
-)
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.core import HexInt
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from .. import (
-    CONF_MAX_PAYLOAD_SIZE,
-    DOMAIN as ESPNOW_DOMAIN,
-    ESPNowComponent,
-    espnow_ns,
-)
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["espnow"]
-
-CONF_ESPNOW_ID = "espnow_id"
-CONF_PEER_ADDRESS = "peer_address"
-
-# The ESP-NOW v1 payload; a larger max_payload_size on the espnow component allows a larger max_packet_size
-MAX_PACKET_SIZE = 250
-BROADCAST_MAC = "FF:FF:FF:FF:FF:FF"
-
-ESPNowPacketInterface = espnow_ns.class_(
-    "ESPNowPacketInterface", packet_interface.PacketInterface
-)
-
-
-def _is_broadcast(config: ConfigType) -> bool:
-    return str(config[CONF_PEER_ADDRESS]) == BROADCAST_MAC
-
-
-def _validate_addressing(config: ConfigType) -> ConfigType:
-    if _is_broadcast(config):
-        check_broadcast_link(config)
-    elif CONF_ADDRESSING in config:
-        raise cv.Invalid(
-            f"Packets to one '{CONF_PEER_ADDRESS}' are already addressed, so '{CONF_ADDRESSING}' is only "
-            "for broadcast",
-            path=[CONF_ADDRESSING],
-        )
-    return config
-
-
-CONFIG_SCHEMA = cv.All(
-    packet_interface_schema(ESPNowPacketInterface, MAX_PACKET_SIZE, 1470).extend(
-        {
-            cv.GenerateID(CONF_ESPNOW_ID): cv.use_id(ESPNowComponent),
-            cv.Optional(CONF_PEER_ADDRESS, default=BROADCAST_MAC): cv.mac_address,
-        }
-    ),
-    _validate_addressing,
-)
-
-
-def _validate_packet_size(config: ConfigType) -> ConfigType:
-    payload = fv.full_config.get()[ESPNOW_DOMAIN][CONF_MAX_PAYLOAD_SIZE]
-    if config[CONF_MAX_PACKET_SIZE] > payload:
-        raise cv.Invalid(
-            f"Must not be larger than the espnow {CONF_MAX_PAYLOAD_SIZE} of {payload}",
-            path=[CONF_MAX_PACKET_SIZE],
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _validate_packet_size
-
-
-async def to_code(config: ConfigType) -> None:
-    parent = await cg.get_variable(config[CONF_ESPNOW_ID])
-    peer = [HexInt(x) for x in config[CONF_PEER_ADDRESS].parts]
-    if not _is_broadcast(config):
-        cg.add(parent.add_peer(peer))
-    # The copy buffer's size is known here, so it is a static array rather than allocated at run time
-    tx_buffer = f"{config[CONF_ID].id}__tx_buffer"
-    cg.add_global(
-        cg.RawStatement(f"static uint8_t {tx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
-    )
-    await new_packet_interface(config, parent, cg.RawExpression(tx_buffer), peer)

esphome/components/espnow/packet_interface/espnow_packet_interface.cpp

@@ -1,125 +0,0 @@
-#include "espnow_packet_interface.h"
-
-#if defined(USE_ESP32) || defined(USE_ESP8266)
-
-#include <cstring>
-
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::espnow {
-
-using packet_interface::PacketBuffer;
-using packet_interface::PacketMetaData;
-
-ESPHOME_LOG_TAG(TAG, "espnow.packet_interface");
-
-ESPNowPacketInterface::ESPNowPacketInterface(ESPNowComponent *parent, std::span<uint8_t> tx_buffer,
-                                             peer_address_t peer_address)
-    : packet_interface::PacketInterface(tx_buffer.size()),
-      parent_(parent),
-      peer_address_(peer_address),
-      tx_buffer_(tx_buffer) {
-  if (!this->is_broadcast_())
-    this->capabilities_ = packet_interface::CAPABILITY_ADDRESSING;
-}
-
-void ESPNowPacketInterface::setup() {
-  // Each mode hears only its own kind of packet, so a peer link and a broadcast link can share the component
-  if (!this->is_broadcast_() || !ESPNOW_REPORTS_DESTINATION)
-    this->parent_->register_receive_handler(this);
-  if (this->is_broadcast_()) {
-    this->parent_->register_broadcast_handler(this);
-    this->parent_->register_unknown_peer_handler(this);
-  }
-}
-
-void ESPNowPacketInterface::dump_config() {
-  char peer_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  format_mac_addr_upper(this->peer_address_.data(), peer_buf);
-  ESP_LOGCONFIG(TAG,
-                "ESP-NOW Packet Interface '%s':\n"
-                "  Peer: %s\n"
-                "  Max Packet Size: %zu",
-                this->name_, peer_buf, this->max_packet_size_);
-}
-
-bool ESPNowPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  // Layers above are set up first, and may send while setup waits for another component
-  if (!this->is_ready())
-    return false;
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  const uint8_t *payload;
-  if (data.is_contiguous()) {
-    payload = data.as_span().data();
-  } else {
-    data.copy_to(this->tx_buffer_.data(), size);
-    payload = this->tx_buffer_.data();
-  }
-  esp_err_t err = this->parent_->send(this->peer_address_.data(), payload, size);
-  if (err != ESP_OK) {
-    this->send_failed_(err);
-    return false;
-  }
-  return true;
-}
-
-// A full send queue is logged by the espnow component, and ESP-NOW is not running before setup or while disabled.
-// Other errors, such as a peer that could not be added, repeat on every send, so warn now and then
-void ESPNowPacketInterface::send_failed_(esp_err_t err) {
-  static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
-  uint32_t now = App.get_loop_component_start_time();
-  if (err == ESP_ERR_ESPNOW_NO_MEM || err == ESP_ERR_ESPNOW_NOT_INIT ||
-      (this->send_warned_ && now - this->last_send_warning_ms_ < WARNING_INTERVAL_MS)) {
-    ESP_LOGV(TAG, "%s: Send failed: %s", this->name_, LOG_STR_ARG(espnow_error_to_str(err)));
-    return;
-  }
-  this->send_warned_ = true;
-  this->last_send_warning_ms_ = now;
-  ESP_LOGW(TAG, "%s: Send failed: %s", this->name_, LOG_STR_ARG(espnow_error_to_str(err)));
-}
-
-bool ESPNowPacketInterface::on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
-  this->receive_(info, data, size);
-  return false;
-}
-
-bool ESPNowPacketInterface::on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
-  this->receive_(info, data, size);
-  return false;
-}
-
-bool ESPNowPacketInterface::on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
-  // Only known peers reach the other handlers; with auto_add_peer this sender is added and arrives there
-  if (this->parent_->get_auto_add_peer())
-    return false;
-  if (!ESPNOW_REPORTS_DESTINATION || memcmp(info.des_addr, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0)
-    this->receive_(info, data, size);
-  return false;
-}
-
-void ESPNowPacketInterface::receive_(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) {
-  if (size == 0)
-    return;
-  if (size > this->max_packet_size_) {
-    ESP_LOGV(TAG, "%s: Packet of %u bytes is larger than %zu, dropped", this->name_, size, this->max_packet_size_);
-    return;
-  }
-  if (!this->is_broadcast_() && memcmp(info.src_addr, this->peer_address_.data(), ESP_NOW_ETH_ALEN) != 0)
-    return;
-  PacketMetaData meta_data;
-  memcpy(meta_data.mac_address, info.src_addr, ESP_NOW_ETH_ALEN);
-#ifdef USE_ESP32
-  meta_data.rssi = info.rx_ctrl->rssi;
-#endif
-  this->on_receive_from_interface_(PacketBuffer(data, size), meta_data);
-}
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32 || USE_ESP8266

esphome/components/espnow/packet_interface/espnow_packet_interface.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "../espnow_component.h"
-
-#if defined(USE_ESP32) || defined(USE_ESP8266)
-
-#include <cstring>
-#include <span>
-
-#include "esphome/components/packet_interface/packet_interface.h"
-
-namespace esphome::espnow {
-
-/**
- * A packet interface link over ESP-NOW.
- *
- * With a peer address other than broadcast, packets go to that device only, and only packets sent to this device by
- * it are received, so the link provides the addressing capability itself. With the broadcast address, packets go to
- * every device on the channel and every broadcast packet is received, from known and unknown senders; an addressing
- * layer then tells the devices apart. ESP8266 does not report a packet's destination, so there a broadcast link also
- * receives packets sent to this device, and a peer link also receives the peer's broadcasts.
- *
- * ESP-NOW queues each packet and reports later whether it was delivered; a reliability layer above resends what is
- * lost.
- */
-class ESPNowPacketInterface : public packet_interface::PacketInterface,
-                              public ESPNowReceivedPacketHandler,
-                              public ESPNowBroadcastHandler,
-                              public ESPNowUnknownPeerHandler {
- public:
-  /// @param tx_buffer Joins packets split across buffers; its size is the largest packet, and it must outlive the link
-  ESPNowPacketInterface(ESPNowComponent *parent, std::span<uint8_t> tx_buffer, peer_address_t peer_address);
-
-  void setup() override;
-  void dump_config() override;
-  bool send_to_interface(const packet_interface::PacketBuffer &data,
-                         const packet_interface::PacketMetaData &meta_data) override;
-
-  bool on_receive(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
-  bool on_broadcast(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
-  bool on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size) override;
-
- protected:
-  bool is_broadcast_() const {
-    return memcmp(this->peer_address_.data(), ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0;
-  }
-  void receive_(const ESPNowRecvInfo &info, const uint8_t *data, uint16_t size);
-  void send_failed_(esp_err_t err);
-
-  ESPNowComponent *parent_;
-  peer_address_t peer_address_;
-  const std::span<uint8_t> tx_buffer_;
-  uint32_t last_send_warning_ms_{0};
-  bool send_warned_{false};
-};
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32 || USE_ESP8266

esphome/components/hmac_sha256/hmac_sha256.cpp

@@ -45,15 +45,14 @@ void HmacSHA256::get_hex(char *output) {
 }
 
 bool HmacSHA256::equals_bytes(const uint8_t *expected) {
-  return constant_time_equals(this->digest_, expected, SHA256_DIGEST_SIZE);
+  return memcmp(this->digest_, expected, SHA256_DIGEST_SIZE) == 0;
 }
 
 bool HmacSHA256::equals_hex(const char *expected) {
-  uint8_t parsed[SHA256_DIGEST_SIZE];
-  if (parse_hex(expected, SHA256_DIGEST_SIZE * 2, parsed, SHA256_DIGEST_SIZE) != SHA256_DIGEST_SIZE * 2) {
-    return false;
-  }
-  return this->equals_bytes(parsed);
+  char hex_output[SHA256_DIGEST_SIZE * 2 + 1];
+  this->get_hex(hex_output);
+  hex_output[SHA256_DIGEST_SIZE * 2] = '\0';
+  return strncmp(hex_output, expected, SHA256_DIGEST_SIZE * 2) == 0;
 }
 
 #elif defined(USE_HMAC_SHA256_MBEDTLS)
@@ -78,15 +77,14 @@ void HmacSHA256::get_hex(char *output) {
 }
 
 bool HmacSHA256::equals_bytes(const uint8_t *expected) {
-  return constant_time_equals(this->digest_, expected, SHA256_DIGEST_SIZE);
+  return memcmp(this->digest_, expected, SHA256_DIGEST_SIZE) == 0;
 }
 
 bool HmacSHA256::equals_hex(const char *expected) {
-  uint8_t parsed[SHA256_DIGEST_SIZE];
-  if (parse_hex(expected, SHA256_DIGEST_SIZE * 2, parsed, SHA256_DIGEST_SIZE) != SHA256_DIGEST_SIZE * 2) {
-    return false;
-  }
-  return this->equals_bytes(parsed);
+  char hex_output[SHA256_DIGEST_SIZE * 2 + 1];
+  this->get_hex(hex_output);
+  hex_output[SHA256_DIGEST_SIZE * 2] = '\0';
+  return strncmp(hex_output, expected, SHA256_DIGEST_SIZE * 2) == 0;
 }
 
 #else

esphome/components/mipi_dsi/display.py

@@ -38,7 +38,6 @@ from esphome.components.mipi import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AUTO_CLEAR_ENABLED,
     CONF_COLOR_ORDER,
     CONF_DIMENSIONS,
     CONF_ENABLE_PIN,
@@ -167,8 +166,7 @@ def _config_schema(config: ConfigType) -> ConfigType:
         height,
         has_hardware_rotation=False,
         byte_order=config[CONF_BYTE_ORDER],
-        has_writer=requires_buffer(config)
-        or config.get(CONF_AUTO_CLEAR_ENABLED) is True,
+        has_writer=display.config_has_writer(config),
         rotation=config.get(CONF_ROTATION, 0),
         draw_rounding=config.get(CONF_DRAW_ROUNDING, 0),
     )

esphome/components/mipi_dsi/mipi_dsi.cpp

@@ -1,6 +1,7 @@
 #ifdef USE_ESP32_VARIANT_ESP32P4
 #include <utility>
 #include "mipi_dsi.h"
+#include "esphome/components/display/init_sequence.h"
 #include "esphome/core/helpers.h"
 
 #include <algorithm>
@@ -123,47 +124,38 @@ void MipiDsi::setup() {
     this->smark_failed(LOG_STR("esp_lcd_init failed"), err);
     return;
   }
-  size_t index = 0;
-  const uint8_t *seq = this->init_sequence_;
-  const size_t len = this->init_sequence_len_;
-  while (index != len) {
-    if (len - index < 2) {
+  display::InitSequenceReader reader(this->init_sequence_, this->init_sequence_len_);
+  display::InitSequenceEntry entry;
+  while (auto step = reader.next(entry)) {
+    if (step == display::INIT_SEQUENCE_STEP_MALFORMED) {
       this->mark_failed(LOG_STR("Malformed init sequence"));
       return;
     }
-    uint8_t cmd = seq[index++];
-    uint8_t x = seq[index++];
-    if (x == DELAY_FLAG) {
-      ESP_LOGD(TAG, "Delay %dms", cmd);
-      delay(cmd);
-    } else {
-      uint8_t num_args = x & 0x7F;
-      if (len - index < num_args) {
-        this->mark_failed(LOG_STR("Malformed init sequence"));
-        return;
-      }
-      if (cmd == SLEEP_OUT) {
-        // are we ready, boots?
-        int duration = when - millis();
-        if (duration > 0) {
-          delay(duration);
-        }
-      }
-      const auto *ptr = seq + index;
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-      char hex_buf[format_hex_pretty_size(MIPI_DSI_MAX_CMD_LOG_BYTES)];
-#endif
-      ESP_LOGVV(TAG, "Command %02X, length %d, byte(s) %s", cmd, num_args,
-                format_hex_pretty_to(hex_buf, ptr, num_args, '.'));
-      err = esp_lcd_panel_io_tx_param(this->io_handle_, cmd, ptr, num_args);
-      if (err != ESP_OK) {
-        this->smark_failed(LOG_STR("lcd_panel_io_tx_param failed"), err);
-        return;
-      }
-      index += num_args;
-      if (cmd == SLEEP_OUT)
-        delay(10);
+    if (step == display::INIT_SEQUENCE_STEP_DELAY) {
+      ESP_LOGD(TAG, "Delay %dms", entry.value);
+      delay(entry.value);
+      continue;
     }
+    const uint8_t cmd = entry.value;
+    if (cmd == SLEEP_OUT) {
+      // are we ready, boots?
+      int duration = when - millis();
+      if (duration > 0) {
+        delay(duration);
+      }
+    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(MIPI_DSI_MAX_CMD_LOG_BYTES)];
+#endif
+    ESP_LOGVV(TAG, "Command %02X, length %d, byte(s) %s", cmd, entry.count,
+              format_hex_pretty_to(hex_buf, entry.args, entry.count, '.'));
+    err = esp_lcd_panel_io_tx_param(this->io_handle_, cmd, entry.args, entry.count);
+    if (err != ESP_OK) {
+      this->smark_failed(LOG_STR("lcd_panel_io_tx_param failed"), err);
+      return;
+    }
+    if (cmd == SLEEP_OUT)
+      delay(10);
   }
   this->io_lock_ = xSemaphoreCreateBinary();
   esp_lcd_dpi_panel_event_callbacks_t cbs = {

esphome/components/mipi_dsi/mipi_dsi.h

@@ -31,7 +31,6 @@ const uint8_t INVERT_OFF = 0x20;
 const uint8_t INVERT_ON = 0x21;
 const uint8_t DISPLAY_ON = 0x29;
 const uint8_t CMD2_BKSEL = 0xFF;
-const uint8_t DELAY_FLAG = 0xFF;
 const uint8_t MADCTL_BGR = 0x08;
 const uint8_t MADCTL_MX = 0x40;
 const uint8_t MADCTL_MY = 0x80;

esphome/components/mipi_rgb/display.py

@@ -50,7 +50,6 @@ from esphome.components.spi import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AUTO_CLEAR_ENABLED,
     CONF_BLUE,
     CONF_COLOR_ORDER,
     CONF_CS_PIN,
@@ -243,8 +242,7 @@ def _config_schema(config: ConfigType) -> ConfigType:
         height,
         has_hardware_rotation=True,
         byte_order=config[CONF_BYTE_ORDER],
-        has_writer=requires_buffer(config)
-        or config.get(CONF_AUTO_CLEAR_ENABLED) is True,
+        has_writer=display.config_has_writer(config),
         rotation=config.get(CONF_ROTATION, 0),
         draw_rounding=config.get(CONF_DRAW_ROUNDING, 0),
     )

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -1,5 +1,6 @@
 #if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S31)
 #include "mipi_rgb.h"
+#include "esphome/components/display/init_sequence.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -13,8 +14,6 @@
 
 namespace esphome::mipi_rgb {
 
-static const uint8_t DELAY_FLAG = 0xFF;
-
 // Maximum bytes to log for init commands (truncated if larger)
 static constexpr size_t MIPI_RGB_MAX_CMD_LOG_BYTES = 64;
 static constexpr uint8_t MADCTL_MY = 0x80;     // Bit 7 Bottom to top
@@ -75,44 +74,30 @@ void MipiRgbSpi::write_data_(uint8_t value) {
   this->disable();
 }
 
-/**
- * this relies upon the init sequence being well-formed, which is guaranteed by the Python init code.
- */
-
 void MipiRgbSpi::write_init_sequence_() {
-  size_t index = 0;
-  const uint8_t *seq = this->init_sequence_;
-  const size_t len = this->init_sequence_len_;
-  while (index != len) {
-    if (len - index < 2) {
+  display::InitSequenceReader reader(this->init_sequence_, this->init_sequence_len_);
+  display::InitSequenceEntry entry;
+  while (auto step = reader.next(entry)) {
+    if (step == display::INIT_SEQUENCE_STEP_MALFORMED) {
       this->mark_failed(LOG_STR("Malformed init sequence"));
       return;
     }
-    uint8_t cmd = seq[index++];
-    uint8_t x = seq[index++];
-    if (x == DELAY_FLAG) {
-      ESP_LOGD(TAG, "Delay %dms", cmd);
-      delay(cmd);
-    } else {
-      uint8_t num_args = x & 0x7F;
-      if (len - index < num_args) {
-        this->mark_failed(LOG_STR("Malformed init sequence"));
-        return;
-      }
-      if (cmd == SLEEP_OUT) {
-        delay(120);  // NOLINT
-      }
-      const auto *ptr = seq + index;
-      char hex_buf[format_hex_pretty_size(MIPI_RGB_MAX_CMD_LOG_BYTES)];
-      ESP_LOGD(TAG, "Write command %02X, length %d, byte(s) %s", cmd, num_args,
-               format_hex_pretty_to(hex_buf, ptr, num_args, '.'));
-      index += num_args;
-      this->write_command_(cmd);
-      while (num_args-- != 0)
-        this->write_data_(*ptr++);
-      if (cmd == SLEEP_OUT)
-        delay(10);
+    if (step == display::INIT_SEQUENCE_STEP_DELAY) {
+      ESP_LOGD(TAG, "Delay %dms", entry.value);
+      delay(entry.value);
+      continue;
     }
+    const uint8_t cmd = entry.value;
+    if (cmd == SLEEP_OUT)
+      delay(120);  // NOLINT
+    char hex_buf[format_hex_pretty_size(MIPI_RGB_MAX_CMD_LOG_BYTES)];
+    ESP_LOGD(TAG, "Write command %02X, length %d, byte(s) %s", cmd, entry.count,
+             format_hex_pretty_to(hex_buf, entry.args, entry.count, '.'));
+    this->write_command_(cmd);
+    for (uint8_t i = 0; i < entry.count; i++)
+      this->write_data_(entry.args[i]);
+    if (cmd == SLEEP_OUT)
+      delay(10);
   }
   // this->spi_teardown();  // SPI not needed after this
   delay(10);

esphome/components/mipi_spi/display.py

@@ -33,7 +33,6 @@ from esphome.components.spi import CONF_SPI_MODE, TYPE_OCTAL, TYPE_QUAD, TYPE_SI
 import esphome.config_validation as cv
 from esphome.config_validation import ALLOW_EXTRA
 from esphome.const import (
-    CONF_AUTO_CLEAR_ENABLED,
     CONF_BRIGHTNESS,
     CONF_BUFFER_SIZE,
     CONF_COLOR_ORDER,
@@ -73,6 +72,10 @@ Model = mipi_spi_ns.enum("Model")
 PixelMode = mipi_spi_ns.enum("PixelMode")
 BusType = mipi_spi_ns.enum("BusType")
 
+# Matches INIT_SEQUENCE_MAX_ARGS, the flash copy buffer in mipi_spi.h
+INIT_SEQUENCE_MAX_ARGS = 128
+
+
 COLOR_ORDERS = {
     MODE_RGB: ColorOrder.COLOR_ORDER_RGB,
     MODE_BGR: ColorOrder.COLOR_ORDER_BGR,
@@ -216,7 +219,15 @@ def model_schema(config: ConfigType) -> cv.All | cv.Schema:
                     bus_mode, lower=True
                 ),
                 cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
-                iseqconf: cv.ensure_list(map_sequence),
+                iseqconf: cv.ensure_list(
+                    cv.All(
+                        map_sequence,
+                        cv.Length(
+                            max=INIT_SEQUENCE_MAX_ARGS + 1,
+                            msg=f"An init sequence command can have at most {INIT_SEQUENCE_MAX_ARGS} data bytes",
+                        ),
+                    )
+                ),
                 cv.Optional(CONF_BUFFER_SIZE): cv.All(
                     cv.percentage, cv.Range(0.12, 1.0)
                 ),
@@ -290,8 +301,7 @@ def customise_schema(config: ConfigType) -> ConfigType:
         height,
         has_hardware_transform,
         byte_order=config[CONF_BYTE_ORDER],
-        has_writer=requires_buffer(config)
-        or config.get(CONF_AUTO_CLEAR_ENABLED) is True,
+        has_writer=display.config_has_writer(config),
         rotation=config.get(CONF_ROTATION, 0),
         draw_rounding=config.get(CONF_DRAW_ROUNDING, 0),
     )

esphome/components/mipi_spi/mipi_spi.h

@@ -7,12 +7,16 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
 #include "esphome/components/display/display_color_utils.h"
+#include "esphome/components/display/init_sequence.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::mipi_spi {
 
+/// Largest argument count in one init command; display.py rejects longer ones.
+static constexpr size_t INIT_SEQUENCE_MAX_ARGS = 128;
+
 ESPHOME_LOG_TAG(TAG, "display.mipi_spi");
 
 // Maximum bytes to log for commands (truncated if larger)
@@ -48,7 +52,6 @@ static constexpr uint8_t MADCTL_XFLIP = 0x02;        // Mirror the display horiz
 static constexpr uint8_t MADCTL_YFLIP = 0x01;        // Mirror the display vertically
 static constexpr uint16_t MADCTL_FLIP_FLAG = 0x100;  // controller uses axis flip bits
 
-static constexpr uint8_t DELAY_FLAG = 0xFF;
 // store a 16 bit value in a buffer, big endian.
 static inline void put16_be(uint8_t *buf, uint16_t value) {
   buf[0] = value >> 8;
@@ -163,36 +166,23 @@ class MipiSpi : public display::Display,
 
     // need to know when the display is ready for SLPOUT command - will be 120ms after reset
     auto when = millis() + 120;
-    size_t index = 0;
-    const uint8_t *seq = this->init_sequence_;
-    const size_t len = this->init_sequence_len_;
-    while (index != len) {
-      if (len - index < 2) {
-        esph_log_e(TAG, "Malformed init sequence");
-        this->mark_failed();
+    display::InitSequenceReader reader(this->init_sequence_, this->init_sequence_len_);
+    display::InitSequenceEntry entry;
+    // The sequence is in flash, which SPI DMA (and ESP8266 byte loads) cannot read
+    uint8_t args[INIT_SEQUENCE_MAX_ARGS];
+    while (auto step = reader.next(entry, sizeof(args))) {
+      if (step == display::INIT_SEQUENCE_STEP_MALFORMED) {
+        this->mark_failed(LOG_STR("Malformed init sequence"));
         return;
       }
-      uint8_t cmd = progmem_read_byte(seq + index++);
-      uint8_t x = progmem_read_byte(seq + index++);
-      if (x == DELAY_FLAG) {
-        if (cmd == 0) {
-          cmd = clamp_at_least((int) (when - millis()), 0);
-        }
-        esph_log_d(TAG, "Delay %dms", cmd);
-        delay(cmd);
-      } else {
-        uint8_t num_args = x & 0x7F;
-        if (len - index < num_args) {
-          esph_log_e(TAG, "Malformed init sequence");
-          this->mark_failed();
-          return;
-        }
-        // The sequence is in flash, which SPI DMA (and ESP8266 byte loads) cannot read
-        uint8_t args[0x80];
-        progmem_memcpy(args, seq + index, num_args);
-        this->write_command_(cmd, args, num_args);
-        index += num_args;
+      if (step == display::INIT_SEQUENCE_STEP_DELAY) {
+        const uint8_t ms = entry.value != 0 ? entry.value : clamp_at_least((int) (when - millis()), 0);
+        esph_log_d(TAG, "Delay %dms", ms);
+        delay(ms);
+        continue;
       }
+      progmem_memcpy(args, entry.args, entry.count);
+      this->write_command_(entry.value, args, entry.count);
     }
     this->reset_params_();
     // Marks init as done, so later commands log at verbose level instead of debug

esphome/components/online_image/download_buffer.cpp

@@ -1,6 +1,5 @@
 #include "download_buffer.h"
 #include "esphome/core/log.h"
-#include <algorithm>
 #include <cstring>
 
 namespace esphome::online_image {
@@ -35,46 +34,6 @@ size_t DownloadBuffer::read(size_t len) {
   return this->unread_;
 }
 
-void DownloadSource::compact() {
-  if (this->keep_read_ || this->pos_ == this->start_)
-    return;
-  this->buffer_.read(this->pos_ - this->start_);
-  this->start_ = this->pos_;
-}
-
-int32_t DownloadSource::read(uint8_t *buf, uint32_t len) {
-  const size_t offset = this->pos_ - this->start_;
-  const size_t n = std::min<size_t>(len, this->buffer_.unread() - offset);
-  memcpy(buf, this->buffer_.data(offset), n);
-  this->pos_ += n;
-  return static_cast<int32_t>(n);
-}
-
-bool DownloadSource::seek(uint32_t position) {
-  // Only what is still in the buffer can be read again; a decoder never skips ahead of the download
-  if (position < this->start_ || position > this->start_ + this->buffer_.unread())
-    return false;
-  this->pos_ = position;
-  return true;
-}
-
-bool DownloadBuffer::grow(size_t size) {
-  if (this->size_ >= size)
-    return true;
-  RAMAllocator<uint8_t> allocator;
-  uint8_t *buffer = allocator.allocate(size);
-  if (buffer == nullptr) {
-    ESP_LOGE(TAG, "allocation of %zu bytes failed. Biggest block in heap: %zu Bytes", size,
-             allocator.get_max_free_block_size());
-    return false;
-  }
-  memcpy(buffer, this->buffer_, this->unread_);
-  allocator.deallocate(this->buffer_, this->size_);
-  this->buffer_ = buffer;
-  this->size_ = size;
-  return true;
-}
-
 size_t DownloadBuffer::resize(size_t size) {
   if (this->size_ >= size) {
     // Avoid useless reallocations; if the buffer is big enough, don't reallocate.

esphome/components/online_image/download_buffer.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "esphome/components/runtime_image/image_decoder.h"
 #include "esphome/core/helpers.h"
 #include <cstddef>
 #include <cstdint>
@@ -36,8 +35,6 @@ class DownloadBuffer {
 
   void reset() { this->unread_ = 0; }
   size_t resize(size_t size);
-  /// Make the buffer at least size bytes, keeping the unread data. Returns false if the allocation failed.
-  bool grow(size_t size);
 
  protected:
   uint8_t *buffer_;
@@ -46,35 +43,4 @@ class DownloadBuffer {
   size_t unread_;
 };
 
-/**
- * @brief Lets a decoder read a download as it arrives, from the download buffer.
- *
- * The decoder reads at its own position in the buffer. Bytes it has read stay there until compact() drops
- * them, and compact() keeps everything while set_keep_read(true) is in effect, so the decoder can seek back
- * while it reads the headers.
- */
-class DownloadSource : public runtime_image::DecodeSource {
- public:
-  explicit DownloadSource(DownloadBuffer &buffer) : buffer_(buffer) {}
-
-  /// Start again at the beginning of a new download, keeping what is read
-  void reset() {
-    this->start_ = 0;
-    this->pos_ = 0;
-    this->keep_read_ = true;
-  }
-  void set_keep_read(bool keep) { this->keep_read_ = keep; }
-  /// Drop the bytes the decoder has read, to make room for more of the download
-  void compact();
-
-  int32_t read(uint8_t *buf, uint32_t len) override;
-  bool seek(uint32_t position) override;
-
- protected:
-  DownloadBuffer &buffer_;
-  size_t start_{0};  // Position in the download of the first byte in the buffer
-  size_t pos_{0};    // Position in the download the decoder reads next
-  bool keep_read_{true};
-};
-
 }  // namespace esphome::online_image

esphome/components/online_image/image.py

@@ -22,8 +22,6 @@ DEPENDENCIES = ["http_request"]
 CODEOWNERS = ["@guillempages", "@clydebarrow"]
 
 CONF_ON_DOWNLOAD_FINISHED = "on_download_finished"
-CONF_ON_DOWNLOAD_STARTED = "on_download_started"
-CONF_ON_DOWNLOAD_PROGRESS = "on_download_progress"
 CONF_UPDATE = "update"
 
 online_image_ns = cg.esphome_ns.namespace("online_image")
@@ -45,9 +43,7 @@ ONLINE_IMAGE_SCHEMA = (
             cv.Optional(CONF_REQUEST_HEADERS): cv.All(
                 cv.Schema({cv.string: cv.templatable(cv.string)})
             ),
-            cv.Optional(CONF_ON_DOWNLOAD_STARTED): automation.validate_automation({}),
             cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation({}),
-            cv.Optional(CONF_ON_DOWNLOAD_PROGRESS): automation.validate_automation({}),
             cv.Optional(CONF_ON_ERROR): automation.validate_automation({}),
         }
     )
@@ -100,17 +96,9 @@ automation.register_apply_action(
 
 
 _CALLBACK_AUTOMATIONS = (
-    automation.CallbackAutomation(
-        CONF_ON_DOWNLOAD_STARTED, "add_on_download_started_callback"
-    ),
     automation.CallbackAutomation(
         CONF_ON_DOWNLOAD_FINISHED, "add_on_finished_callback", [(bool, "cached")]
     ),
-    automation.CallbackAutomation(
-        CONF_ON_DOWNLOAD_PROGRESS,
-        "add_on_progress_callback",
-        [(float, "progress"), (cg.size_t, "bytes_read")],
-    ),
     automation.CallbackAutomation(CONF_ON_ERROR, "add_on_error_callback"),
 )
 

esphome/components/online_image/online_image.cpp

@@ -4,7 +4,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <algorithm>
-#include <cmath>
 #include <cstdio>
 
 ESPHOME_LOG_TAG(TAG, "online_image");
@@ -16,11 +15,6 @@ static const char *const IF_MODIFIED_SINCE_HEADER_NAME = "if-modified-since";
 
 namespace esphome::online_image {
 
-// Time one loop pass may spend reading, and decoding a JPEG as it downloads
-static constexpr uint32_t PASS_BUDGET_MS = 20;
-// Shortest time between two on_download_progress calls
-static constexpr uint32_t PROGRESS_INTERVAL_MS = 100;
-
 OnlineImage::OnlineImage(const std::string &url, int width, int height, runtime_image::ImageFormat format,
                          image::ImageType type, image::Transparency transparency, image::Image *placeholder,
                          uint32_t buffer_size, bool is_big_endian)
@@ -146,12 +140,8 @@ void OnlineImage::update() {
     return;
   }
 
-  // A JPEG of known size is decoded as it arrives, so the download buffer only has to hold its headers.
-  // Otherwise the decoder needs the complete image in the buffer.
-  this->streaming_ = total_size > 0 && total_size <= INT32_MAX && this->decoder_supports_source();
-  this->stream_started_ = false;
-  this->source_.reset();
-  if (!this->streaming_ && format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
+  // JPEG requires the complete image in the download buffer before decoding
+  if (format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
       this->download_buffer_.resize(total_size) == 0) {
     // resize() logged the failed allocation; the next update() allocates the configured buffer again
     this->end_connection_();
@@ -162,8 +152,6 @@ void OnlineImage::update() {
   ESP_LOGI(TAG, "Downloading image (Size: %zu)", total_size);
   this->start_time_ = millis();
   this->last_data_time_ = this->start_time_;
-  this->download_started_callback_.call();
-  this->report_progress_(true);
   this->enable_loop();
 }
 
@@ -181,11 +169,6 @@ void OnlineImage::loop() {
     return;
   }
 
-  if (this->streaming_) {
-    this->loop_stream_();
-    return;
-  }
-
   // Check if download is complete — use decoder's format-specific completion check
   // to handle both known content-length and chunked transfer encoding
   if (this->is_decode_finished() || (this->downloader_->content_length > 0 &&
@@ -196,22 +179,15 @@ void OnlineImage::loop() {
   }
 
   // Download and decode more data
-  if (this->download_buffer_.free_capacity() > 0) {
-    const uint32_t now = App.get_loop_component_start_time();
-    size_t received = 0;
-    int len;
-    do {
-      len = this->downloader_->read(this->download_buffer_.append(),
-                                    std::min(this->download_buffer_.free_capacity(), READ_CHUNK));
-      if (len <= 0)
-        break;
-      this->download_buffer_.write(len);
-      received += len;
-    } while (this->download_buffer_.free_capacity() != 0 && millis() - now < PASS_BUDGET_MS);
+  size_t available = this->download_buffer_.free_capacity();
+  if (available > 0) {
+    // Download in chunks to avoid blocking
+    available = std::min(available, this->download_buffer_initial_size_);
+    auto len = this->downloader_->read(this->download_buffer_.append(), available);
 
-    if (received > 0) {
-      this->last_data_time_ = now;
-      this->report_progress_(false);
+    if (len > 0) {
+      this->last_data_time_ = App.get_loop_component_start_time();
+      this->download_buffer_.write(len);
 
       // Feed data to decoder
       auto consumed = this->feed_data(this->download_buffer_.data(), this->download_buffer_.unread());
@@ -279,114 +255,6 @@ void OnlineImage::loop() {
   }
 }
 
-void OnlineImage::loop_stream_() {
-  const uint32_t now = App.get_loop_component_start_time();
-  const size_t total = this->downloader_->content_length;
-  if (this->stream_started_)
-    this->source_.compact();
-
-  if (this->downloader_->get_bytes_read() < total) {
-    if (this->download_buffer_.free_capacity() == 0) {
-      // compact() already ran, so a full buffer means the decoder read nothing in the last pass
-      if (now - this->last_data_time_ >= this->parent_->get_timeout()) {
-        ESP_LOGE(TAG, "Image does not fit in the %zu byte download buffer; increase buffer_size",
-                 this->download_buffer_.size());
-        this->fail_download_();
-        return;
-      }
-    } else {
-      int len;
-      do {
-        len = this->downloader_->read(this->download_buffer_.append(),
-                                      std::min(this->download_buffer_.free_capacity(), READ_CHUNK));
-        if (len <= 0)
-          break;
-        this->last_data_time_ = now;
-        this->download_buffer_.write(len);
-        this->report_progress_(false);
-      } while (this->downloader_->get_bytes_read() < total && this->download_buffer_.free_capacity() != 0 &&
-               millis() - now < PASS_BUDGET_MS);
-      if (len < 0) {
-        ESP_LOGE(TAG, "Error downloading image: %d", len);
-        this->fail_download_();
-        return;
-      } else if (now - this->last_data_time_ >= this->parent_->get_timeout()) {
-        ESP_LOGE(TAG, "No data received for %" PRIu32 " ms", this->parent_->get_timeout());
-        this->fail_download_();
-        return;
-      }
-    }
-  }
-  const bool arrived = this->downloader_->get_bytes_read() >= total;
-
-  if (!this->stream_started_) {
-    // The decoder reads the headers when it opens the image, so wait until they are in the buffer
-    if (!arrived && this->download_buffer_.free_capacity() != 0)
-      return;
-    const int err = this->begin_source(&this->source_);
-    if (err != 0) {
-      // Headers cut short by a full buffer fail to parse, or make the decoder seek past the buffer. Such an image
-      // still decodes once it is all in memory, as it did before JPEG images were decoded as they download.
-      if (!arrived && (err == runtime_image::DECODE_ERROR_INVALID_TYPE || err == runtime_image::DECODE_ERROR_READ)) {
-        ESP_LOGW(TAG,
-                 "The image headers do not fit the %zu byte download buffer, so the whole image is downloaded "
-                 "before it is decoded; increase buffer_size to decode it as it downloads",
-                 this->download_buffer_.size());
-        // grow() logs a failed allocation
-        if (this->download_buffer_.grow(total)) {
-          this->streaming_ = false;
-        } else {
-          this->fail_download_();
-        }
-        return;
-      }
-      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(err));
-      this->fail_download_();
-      return;
-    }
-    this->source_.set_keep_read(false);
-    this->stream_started_ = true;
-    // Opening the image and allocating its buffer is enough for one pass
-    return;
-  }
-
-  do {
-    const int result = this->decode_step();
-    if (result == runtime_image::DECODE_STEP_MORE)
-      continue;
-    if (result == runtime_image::DECODE_STEP_DONE) {
-      this->finish_download_();
-    } else if (result == runtime_image::DECODE_STEP_NEED_DATA) {
-      if (!arrived)
-        return;
-      // JPEGDEC only waits for bytes short of the size it was given, so this guards against a hang
-      ESP_LOGE(TAG, "Download ended before the image was complete");
-      this->fail_download_();
-    } else {
-      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(result));
-      this->fail_download_();
-    }
-    return;
-  } while (millis() - now < PASS_BUDGET_MS);
-}
-
-void OnlineImage::report_progress_(bool force) {
-  const uint32_t now = App.get_loop_component_start_time();
-  const size_t bytes = this->downloader_->get_bytes_read();
-  const size_t total = this->downloader_->content_length;
-  // The last bytes are always reported, so a progress bar reaches 100%
-  if (!force && now - this->last_progress_time_ < PROGRESS_INTERVAL_MS && (total == 0 || bytes < total))
-    return;
-  this->last_progress_time_ = now;
-  const float progress = total > 0 ? std::min(100.0f, bytes * 100.0f / total) : NAN;
-  this->download_progress_callback_.call(progress, bytes);
-}
-
-void OnlineImage::fail_download_() {
-  this->end_connection_();
-  this->download_error_callback_.call();
-}
-
 void OnlineImage::finish_download_() {
   // Must be read before end_decode() ends the decoding session
   bool decoder_finished = this->is_decode_finished();
@@ -420,8 +288,6 @@ void OnlineImage::end_connection_() {
     this->downloader_ = nullptr;
   }
   this->download_buffer_.reset();
-  this->streaming_ = false;
-  this->stream_started_ = false;
   this->disable_loop();
 }
 

esphome/components/online_image/online_image.h

@@ -16,10 +16,6 @@ using t_http_codes = enum {
   HTTP_CODE_NOT_FOUND = 404,
 };
 
-/// Largest download read(). A read() blocks until it has every byte it asked for, so this bounds how long one loop
-/// pass waits on a slow link.
-static constexpr size_t READ_CHUNK = 1460;
-
 /**
  * @brief Download an image from a given URL, and decode it using the specified decoder.
  * The image will then be stored in a buffer, so that it can be re-displayed without the
@@ -74,17 +70,9 @@ class OnlineImage final : public PollingComponent,
    */
   void release();
 
-  /// Called when the server has accepted the request and the image starts to download
-  template<typename F> void add_on_download_started_callback(F &&callback) {
-    this->download_started_callback_.add(std::forward<F>(callback));
-  }
   template<typename F> void add_on_finished_callback(F &&callback) {
     this->download_finished_callback_.add(std::forward<F>(callback));
   }
-  /// Called with the percentage downloaded (NAN when the server did not send the size) and the bytes read so far
-  template<typename F> void add_on_progress_callback(F &&callback) {
-    this->download_progress_callback_.add(std::forward<F>(callback));
-  }
   template<typename F> void add_on_error_callback(F &&callback) {
     this->download_error_callback_.add(std::forward<F>(callback));
   }
@@ -93,20 +81,12 @@ class OnlineImage final : public PollingComponent,
   bool validate_url_(const std::string &url);
   void end_connection_();
   void finish_download_();
-  /// loop() for a JPEG that is decoded as it downloads
-  void loop_stream_();
-  void fail_download_();
-  /// Reports download progress, at most every PROGRESS_INTERVAL_MS unless force is set
-  void report_progress_(bool force);
 
   CallbackManager<void(bool)> download_finished_callback_{};
   CallbackManager<void()> download_error_callback_{};
-  LazyCallbackManager<void()> download_started_callback_{};
-  LazyCallbackManager<void(float, size_t)> download_progress_callback_{};
 
   std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
   DownloadBuffer download_buffer_;
-  DownloadSource source_{download_buffer_};
   /**
    * This is the *initial* size of the download buffer, not the current size.
    * The download buffer can be resized at runtime; the download_buffer_initial_size_
@@ -129,9 +109,6 @@ class OnlineImage final : public PollingComponent,
 
   uint32_t start_time_{0};
   uint32_t last_data_time_{0};
-  uint32_t last_progress_time_{0};
-  bool streaming_{false};       // The decoder reads the download itself, as it arrives
-  bool stream_started_{false};  // The decoder has read the headers
 };
 
 }  // namespace esphome::online_image

esphome/components/packet_interface/__init__.py

@@ -1,212 +0,0 @@
-from collections.abc import Callable
-import importlib
-import pkgutil
-from typing import Any
-
-import esphome.codegen as cg
-from esphome.components.const import CONF_MAX_PACKET_SIZE
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, MockObjClass
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from . import layers
-from .layers import (
-    ADDRESSING,
-    BROADCAST_ADDRESS,
-    CONF_ADDRESSING,
-    CONF_DESTINATION,
-    CONF_PEERS,
-    CONF_SESSION,
-    STACK_ORDER,
-    PacketInterface,
-    build_stack,
-    check_packet_sizes,
-    check_session,
-    check_single_peer,
-    layer_needing_session,
-    packet_interface_ns,
-    stack_auto_load,
-    stack_schema,
-)
-
-CODEOWNERS = ["@clydebarrow"]
-DOMAIN = "packet_interface"
-IS_PLATFORM_COMPONENT = True
-
-CONF_PACKET_INTERFACE = "packet_interface"
-
-# Each module in layers registers a layer type; import them all before building the schemas from the registry
-for module_info in pkgutil.iter_modules(layers.__path__):
-    importlib.import_module(f".layers.{module_info.name}", package=__package__)
-
-# The layer keys that each link class does itself, by class name
-_PROVIDED_LAYERS: dict[str, tuple[str, ...]] = {}
-
-LINK_LAYER_SCHEMAS = {
-    cv.Optional(CONF_ADDRESSING): ADDRESSING.schema(),
-    **stack_schema(),
-}
-
-__all__ = [
-    "CONF_MAX_PACKET_SIZE",
-    "CONF_PACKET_INTERFACE",
-    "interface_has_layer",
-    "interface_layers",
-    "PacketInterface",
-    "final_validate_interface",
-    "new_packet_interface",
-    "packet_interface_ns",
-    "packet_interface_schema",
-]
-
-
-def AUTO_LOAD(config: list[ConfigType] | None = None) -> list[str]:
-    """Load only what the configured layers use, on the link and in each addressing peer.
-
-    Without a config, as tooling that lists dependencies calls it, everything a layer could load.
-    """
-    if config is None:
-        return ["binary_sensor", "xxtea"]
-    loads: set[str] = set()
-    for interface in config:
-        loads |= stack_auto_load(interface)
-        for peer in interface.get(CONF_ADDRESSING, {}).get(CONF_PEERS, []):
-            loads |= stack_auto_load(peer)
-    return sorted(loads)
-
-
-def _validate_layers(config: ConfigType) -> ConfigType:
-    """With peers, the layers go in each peer; otherwise check them against the one destination."""
-    check_session(config)
-    size = config[CONF_MAX_PACKET_SIZE]
-    if (addressing := config.get(CONF_ADDRESSING)) is None:
-        check_packet_sizes(config, size)
-        return config
-    size = ADDRESSING.get_type(addressing).packet_size(addressing, size)
-    if CONF_PEERS in addressing:
-        for kind in STACK_ORDER:
-            if kind.key in config:
-                raise cv.Invalid(
-                    f"With '{CONF_PEERS}', '{kind.key}' goes in each peer",
-                    path=[kind.key],
-                )
-        for index, peer in enumerate(addressing[CONF_PEERS]):
-            try:
-                check_packet_sizes(peer, size)
-            except cv.Invalid as err:
-                err.prepend([CONF_ADDRESSING, CONF_PEERS, index])
-                raise
-        return config
-    addressing.setdefault(CONF_DESTINATION, BROADCAST_ADDRESS)
-    check_single_peer(config, addressing[CONF_DESTINATION])
-    check_packet_sizes(config, size)
-    return config
-
-
-def interface_layers(interface_id: ID) -> ConfigType | None:
-    """During final validation, the configuration holding the layers of the packet interface with this id.
-
-    The id is a link's, or an addressing peer's.
-    """
-    for interface in fv.full_config.get().get(DOMAIN, []):
-        if interface[CONF_ID].id == interface_id.id:
-            return interface
-        for peer in interface.get(CONF_ADDRESSING, {}).get(CONF_PEERS, []):
-            if peer[CONF_ID].id == interface_id.id:
-                return peer
-    return None
-
-
-def interface_has_layer(interface_id: ID, key: str) -> bool:
-    """During final validation, whether the packet interface with this id has the layer, configured or done by its link."""
-    interface = interface_layers(interface_id)
-    if interface is None:
-        return False
-    return key in interface or key in _PROVIDED_LAYERS.get(
-        str(interface[CONF_ID].type), ()
-    )
-
-
-def final_validate_interface(key: str) -> Callable[[ConfigType], ConfigType]:
-    """Final validation for an application: a link with peers must be used through one of the peers."""
-
-    def validator(config: ConfigType) -> ConfigType:
-        interface_id: ID = config[key]
-        interface = interface_layers(interface_id)
-        if interface is not None and (
-            peers := interface.get(CONF_ADDRESSING, {}).get(CONF_PEERS)
-        ):
-            raise cv.Invalid(
-                f"'{interface_id.id}' has peers, so use the id of one of them, such as '{peers[0][CONF_ID].id}'",
-                path=[key],
-            )
-        return config
-
-    return validator
-
-
-def _check_provided_session(config: ConfigType) -> ConfigType:
-    """A link's own session does not send packets through the layers, so none can need them from the peer."""
-    if key := layer_needing_session(config):
-        raise cv.Invalid(
-            f"This '{key}' needs packets from the peer, which this link does not send through its layers, "
-            "so it cannot be used on this link",
-            path=[key],
-        )
-    return config
-
-
-def packet_interface_schema(
-    class_: MockObjClass,
-    default_max_packet_size: int,
-    max_packet_size_limit: int = 4096,
-    provides: tuple[str, ...] = (),
-) -> cv.Schema:
-    """Schema for a link platform; provides names the layer keys, such as reliability, that the link does itself."""
-    if provides:
-        _PROVIDED_LAYERS[str(class_)] = provides
-    link_layers = {
-        key: (
-            cv.invalid(f"This link provides '{key}' itself, so it cannot be configured")
-            if key in provides
-            else schema
-        )
-        for key, schema in LINK_LAYER_SCHEMAS.items()
-    }
-    schema = cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(class_),
-            cv.Optional(
-                CONF_MAX_PACKET_SIZE, default=default_max_packet_size
-            ): cv.int_range(16, max_packet_size_limit),
-            **link_layers,
-        }
-    ).extend(cv.COMPONENT_SCHEMA)
-    if CONF_SESSION in provides:
-        schema = schema.add_extra(_check_provided_session)
-    return schema.add_extra(_validate_layers)
-
-
-async def new_packet_interface(config: ConfigType, *args: Any) -> MockObj:
-    """Create the link layer and the layers configured on it, from the bottom up.
-
-    The link's constructor takes its maximum packet size, usually as a std::span over a buffer that code generation
-    sized from the configuration, so the two cannot differ.
-
-    Returns the link layer; applications reach the top layer with PacketInterface::top(). With several addressing
-    peers, applications use the peers' ids instead.
-    """
-    var = cg.new_Pvariable(config[CONF_ID], *args)
-    cg.add(var.set_name(config[CONF_ID].id))
-    await cg.register_component(var, config)
-    if (addressing := config.get(CONF_ADDRESSING)) is None:
-        await build_stack(config, var)
-        return var
-    for port, layers_config in await ADDRESSING.get_type(addressing).build(
-        addressing, var
-    ):
-        await build_stack(config if layers_config is None else layers_config, port)
-    return var

esphome/components/packet_interface/basic_addressing.cpp

@@ -1,97 +0,0 @@
-#include "basic_addressing.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_ADDRESSING
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.addressing");
-
-void BasicAddressing::setup() {
-  this->link_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
-}
-
-void BasicAddressing::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Basic Addressing on '%s':\n"
-                "  Address: 0x%04X",
-                this->link_->get_name(), this->address_);
-}
-
-bool BasicAddressing::send(const PacketBuffer &data, const PacketMetaData &meta_data, uint16_t destination) {
-  if (meta_data.destination_address != 0)
-    destination = meta_data.destination_address;
-  uint8_t header[HEADER_SIZE] = {static_cast<uint8_t>(destination), static_cast<uint8_t>(destination >> 8),
-                                 static_cast<uint8_t>(this->address_), static_cast<uint8_t>(this->address_ >> 8)};
-  PacketBuffer packet(header, HEADER_SIZE, &data, nullptr, 0);
-  return this->link_->send_to_interface(packet, meta_data);
-}
-
-void BasicAddressing::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  // Lower layers deliver packets in one piece; the payload is passed up without copying
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "%s: Packet split across buffers is not supported", this->link_->get_name());
-    return;
-  }
-  auto packet = data.as_span();
-  if (packet.size() < HEADER_SIZE) {
-    ESP_LOGV(TAG, "%s: Packet of %zu bytes is shorter than the address header, dropped", this->link_->get_name(),
-             packet.size());
-    return;
-  }
-  uint16_t destination = encode_uint16(packet[1], packet[0]);
-  uint16_t source = encode_uint16(packet[3], packet[2]);
-  if (source == this->address_ || (destination != this->address_ && destination != BROADCAST_ADDRESS))
-    return;
-  AddressingPort *source_port = nullptr;
-  AddressingPort *broadcast_port = nullptr;
-  for (auto *port : this->ports_) {
-    if (port->destination_ == source) {
-      source_port = port;
-    } else if (port->destination_ == BROADCAST_ADDRESS) {
-      broadcast_port = port;
-    }
-  }
-  // A broadcast goes to the broadcast port, even from a device with a port of its own, as that port's layers expect
-  // only its point-to-point packets; anything else goes to the source's port, or to the broadcast port if it has none
-  AddressingPort *target = source_port;
-  if (broadcast_port != nullptr && (destination == BROADCAST_ADDRESS || source_port == nullptr))
-    target = broadcast_port;
-  if (target == nullptr) {
-    ESP_LOGV(TAG, "%s: Packet from 0x%04X dropped", this->link_->get_name(), source);
-    return;
-  }
-  PacketMetaData received = meta_data;
-  received.source_address = source;
-  received.destination_address = destination;
-  target->on_receive_from_interface_(PacketBuffer(packet.data() + HEADER_SIZE, packet.size() - HEADER_SIZE), received);
-}
-
-AddressingPort::AddressingPort(BasicAddressing *addressing, uint16_t destination, bool only_port)
-    : PacketInterface(
-          remaining_packet_size(addressing->get_link()->get_max_packet_size(), BasicAddressing::HEADER_SIZE)),
-      addressing_(addressing),
-      destination_(destination) {
-  if (only_port) {
-    this->stack_on_(addressing->get_link(), CAPABILITY_ADDRESSING);
-  } else {
-    this->inherit_from_(addressing->get_link(), CAPABILITY_ADDRESSING);
-  }
-  // A link with no room leaves the layers above none either, so they fail their setup
-  addressing->add_port(this);
-}
-
-void AddressingPort::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Addressing Port '%s':\n"
-                "  Max Packet Size: %zu",
-                this->name_, this->max_packet_size_);
-  if (this->destination_ == BasicAddressing::BROADCAST_ADDRESS) {
-    ESP_LOGCONFIG(TAG, "  Destination: broadcast");
-  } else {
-    ESP_LOGCONFIG(TAG, "  Destination: 0x%04X", this->destination_);
-  }
-}
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/basic_addressing.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_ADDRESSING
-#include "esphome/core/helpers.h"
-#include "packet_interface.h"
-
-namespace esphome::packet_interface {
-
-class AddressingPort;
-
-/**
- * An addressing layer for channels shared by several devices, such as an RS485 bus or a LoRa radio.
- *
- * Each packet starts with a 16-bit destination address and a 16-bit source address, little endian.
- * BROADCAST_ADDRESS sends to every device. A packet is dropped unless it is addressed to this device or broadcast, and
- * a packet from this device's own address, such as an echo on a half-duplex bus, is dropped too.
- *
- * Above this layer are one or more ports, each the bottom of its own stack of layers. A port with a destination
- * address is a point-to-point link to that device: it sends to it and receives only its packets, so the reliability
- * and session layers and the rolling code, which work between two devices only, can be used above it. A port with
- * the broadcast destination sends to every device, and receives every broadcast, as well as packets from devices
- * that have no port of their own. Without a broadcast port, a device's broadcasts go to its own port.
- */
-class BasicAddressing : public Component {
- public:
-  static constexpr uint16_t BROADCAST_ADDRESS = 0xFFFF;
-  /// Destination and source addresses.
-  static constexpr size_t HEADER_SIZE = 4;
-
-  BasicAddressing(PacketInterface *link, uint16_t address) : link_(link), address_(address) {}
-
-  void setup() override;
-  void dump_config() override;
-
-  PacketInterface *get_link() const { return this->link_; }
-  void add_port(AddressingPort *port) { this->ports_.push_back(port); }
-  /// Sends \p data to \p destination, or to the destination in \p meta_data if set.
-  bool send(const PacketBuffer &data, const PacketMetaData &meta_data, uint16_t destination);
-
- protected:
-  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
-
-  PacketInterface *link_;
-  const uint16_t address_;
-  StaticVector<AddressingPort *, PACKET_INTERFACE_ADDRESSING_PORT_COUNT> ports_;
-};
-
-/// The bottom of the stack of layers for one destination, or for broadcast, on an addressed channel.
-class AddressingPort : public PacketInterface {
- public:
-  /// With \p only_port, the port is the top of the link, so top() on the link reaches this port's stack.
-  AddressingPort(BasicAddressing *addressing, uint16_t destination, bool only_port);
-
-  void dump_config() override;
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override {
-    return this->addressing_->send(data, meta_data, this->destination_);
-  }
-  uint16_t get_destination() const { return this->destination_; }
-
- protected:
-  friend class BasicAddressing;
-
-  BasicAddressing *addressing_;
-  const uint16_t destination_;
-};
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/basic_fragmentation.cpp

@@ -1,160 +0,0 @@
-#include "basic_fragmentation.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_FRAGMENTATION
-#include <algorithm>
-#include <cstring>
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.fragmentation");
-
-static constexpr uint8_t LAST_FRAGMENT = 0x80;
-static constexpr uint8_t INDEX_MASK = 0x7F;
-
-BasicFragmentation::BasicFragmentation(PacketInterface *lower, size_t max_packet_size)
-    : PacketInterface(max_packet_size), lower_(lower) {
-  this->stack_on_(lower, CAPABILITY_FRAGMENTATION);
-}
-
-size_t BasicFragmentation::fragments_for_(size_t size) const {
-  size_t fragment_size = this->fragment_size_();
-  if (fragment_size == 0)
-    return SIZE_MAX;
-  return std::max<size_t>(1, (size + fragment_size - 1) / fragment_size);
-}
-
-void BasicFragmentation::setup() {
-  if (this->fragment_size_() == 0) {
-    this->mark_failed(LOG_STR("max_packet_size too small for the configured layers"));
-    return;
-  }
-  if (this->fragments_for_(this->max_packet_size_) > MAX_FRAGMENTS) {
-    this->mark_failed(LOG_STR("max_packet_size needs more than 128 fragments"));
-    return;
-  }
-  // Checked now, while the layer below holds nothing; a failed layer below reports its own failure instead
-  this->queue_too_short_ =
-      !this->lower_->is_failed() && this->fragments_for_(this->max_packet_size_) > this->lower_->get_send_capacity();
-  RAMAllocator<uint8_t> allocator;
-  this->tx_buffer_ = allocator.allocate(this->fragment_size_() + this->max_packet_size_);
-  if (this->tx_buffer_ == nullptr) {
-    this->mark_failed(LOG_STR("Not enough memory for the packet buffers"));
-    return;
-  }
-  this->rx_buffer_ = this->tx_buffer_ + this->fragment_size_();
-  // Numbering from a random start makes it unlikely that a packet joins fragments from before a restart
-  this->tx_number_ = random_uint32();
-  this->lower_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
-}
-
-void BasicFragmentation::dump_config() {
-  // A link with no room for fragments fails setup, which core reports below
-  size_t fragments = this->fragment_size_() == 0 ? 0 : this->fragments_for_(this->max_packet_size_);
-  ESP_LOGCONFIG(TAG,
-                "Basic Fragmentation on '%s':\n"
-                "  Max Packet Size: %zu\n"
-                "  Fragment Size: %zu\n"
-                "  Fragments in the Largest Packet: %zu",
-                this->name_, this->max_packet_size_, this->fragment_size_(), fragments);
-  if (this->queue_too_short_) {
-    ESP_LOGW(TAG, "  The reliability queue is too short for the largest packets, which cannot be sent");
-  }
-}
-
-bool BasicFragmentation::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  if (this->tx_buffer_ == nullptr)
-    return false;
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  size_t fragments = this->fragments_for_(size);
-  if (fragments > this->lower_->get_send_capacity()) {
-    ESP_LOGV(TAG, "%s: No room for %zu fragments", this->name_, fragments);
-    return false;
-  }
-  uint8_t header[HEADER_SIZE] = {this->tx_number_++, 0};
-  if (fragments == 1) {
-    header[1] = LAST_FRAGMENT;
-    return this->lower_->send_to_interface(PacketBuffer(header, HEADER_SIZE, &data, nullptr, 0), meta_data);
-  }
-  size_t fragment_size = this->fragment_size_();
-  for (size_t index = 0; index != fragments; index++) {
-    size_t length = data.copy_to(this->tx_buffer_, fragment_size, index * fragment_size);
-    header[1] = index | (index + 1 == fragments ? LAST_FRAGMENT : 0);
-    PacketBuffer body(this->tx_buffer_, length);
-    if (!this->lower_->send_to_interface(PacketBuffer(header, HEADER_SIZE, &body, nullptr, 0), meta_data)) {
-      // The peer drops the part already sent when the next packet starts
-      ESP_LOGV(TAG, "%s: Fragment %zu of %zu not accepted", this->name_, index, fragments);
-      return false;
-    }
-  }
-  return true;
-}
-
-void BasicFragmentation::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  // Lower layers deliver packets in one piece; a packet in one fragment is passed up without copying
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "%s: Packet split across buffers is not supported", this->name_);
-    return;
-  }
-  auto fragment = data.as_span();
-  if (fragment.size() < HEADER_SIZE) {
-    ESP_LOGV(TAG, "%s: Fragment of %zu bytes is shorter than its header, dropped", this->name_, fragment.size());
-    return;
-  }
-  uint8_t number = fragment[0];
-  uint8_t index = fragment[1] & INDEX_MASK;
-  bool last = (fragment[1] & LAST_FRAGMENT) != 0;
-  const uint8_t *payload = fragment.data() + HEADER_SIZE;
-  size_t length = fragment.size() - HEADER_SIZE;
-  if (index == 0 && last) {
-    // A packet in one fragment leaves a packet being joined from another device intact
-    if (this->rx_joining_ && meta_data.source_address == this->rx_source_) {
-      ESP_LOGV(TAG, "%s: Incomplete packet %u dropped", this->name_, this->rx_number_);
-      this->rx_joining_ = false;
-    }
-    if (length > this->max_packet_size_) {
-      ESP_LOGV(TAG, "%s: Packet %u is larger than %zu, dropped", this->name_, number, this->max_packet_size_);
-      return;
-    }
-    this->on_receive_from_interface_(PacketBuffer(payload, length), meta_data);
-    return;
-  }
-  if (index == 0) {
-    if (this->rx_joining_) {
-      ESP_LOGV(TAG, "%s: Incomplete packet %u dropped", this->name_, this->rx_number_);
-    }
-    this->rx_joining_ = true;
-    this->rx_number_ = number;
-    this->rx_source_ = meta_data.source_address;
-    this->rx_next_index_ = 0;
-    this->rx_length_ = 0;
-  } else if (this->rx_joining_ && meta_data.source_address != this->rx_source_) {
-    // Only this fragment is lost, so of two devices sending at once, the one that started last still gets through
-    ESP_LOGV(TAG, "%s: Fragment %u from 0x%04X dropped", this->name_, index, meta_data.source_address);
-    return;
-  } else if (!this->rx_joining_ || number != this->rx_number_ || index != this->rx_next_index_) {
-    ESP_LOGV(TAG, "%s: Fragment %u of packet %u dropped", this->name_, index, number);
-    this->rx_joining_ = false;
-    return;
-  }
-  if (this->rx_length_ + length > this->max_packet_size_) {
-    ESP_LOGV(TAG, "%s: Packet %u is larger than %zu, dropped", this->name_, number, this->max_packet_size_);
-    this->rx_joining_ = false;
-    return;
-  }
-  memcpy(this->rx_buffer_ + this->rx_length_, payload, length);
-  this->rx_length_ += length;
-  this->rx_next_index_++;
-  if (last) {
-    this->rx_joining_ = false;
-    this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_, this->rx_length_), meta_data);
-  }
-}
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/basic_fragmentation.h

@@ -1,60 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_FRAGMENTATION
-
-#include "packet_interface.h"
-
-namespace esphome::packet_interface {
-
-/**
- * A fragmentation layer: packets up to this layer's max_packet_size are split into fragments that fit the layer
- * below, and joined again at the other end.
- *
- * Each fragment starts with a 2 byte header: an 8-bit packet number, then the fragment's index in bits 0-6, with bit
- * 7 set on the last fragment. A packet that fits in one fragment still has the header, and is sent and passed up
- * without being copied.
- *
- * A packet is started only if the layer below can take all of its fragments now (get_send_capacity()), so a full
- * reliability queue does not leave the peer with part of a packet. The receiver joins one packet at a time, and drops
- * it when a fragment is missing or arrives with another packet number, or when the same source, or another one,
- * starts a new packet of several fragments. Other fragments from another source address are dropped, leaving the
- * packet being joined intact. Above a reliability layer, fragments arrive in order and none are missing.
- */
-class BasicFragmentation : public PacketInterface {
- public:
-  /// Packet number, then index and last flag.
-  static constexpr size_t HEADER_SIZE = 2;
-  /// The index has 7 bits.
-  static constexpr size_t MAX_FRAGMENTS = 128;
-
-  BasicFragmentation(PacketInterface *lower, size_t max_packet_size);
-
-  void setup() override;
-  void dump_config() override;
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
-
- protected:
-  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
-  size_t fragment_size_() const {
-    size_t lower_size = this->lower_->get_max_packet_size();
-    return lower_size > HEADER_SIZE ? lower_size - HEADER_SIZE : 0;
-  }
-  size_t fragments_for_(size_t size) const;
-
-  PacketInterface *lower_;
-  // One fragment being sent, and the packet being joined; one block allocated in setup(), and tx_buffer_ stays null
-  // if that fails
-  uint8_t *tx_buffer_{nullptr};
-  uint8_t *rx_buffer_{nullptr};
-  size_t rx_length_{0};
-  uint16_t rx_source_{0};
-  uint8_t tx_number_{0};
-  uint8_t rx_number_{0};
-  uint8_t rx_next_index_{0};
-  bool rx_joining_{false};
-  bool queue_too_short_{false};
-};
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/basic_session.cpp

@@ -1,135 +0,0 @@
-#include "basic_session.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_SESSION
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.session");
-
-static constexpr uint8_t PACKET_TYPE_DATA = 0x00;
-static constexpr uint8_t PACKET_TYPE_KEEP_ALIVE = 0x01;
-// Type byte and the 32-bit boot id, little endian
-static constexpr size_t KEEP_ALIVE_SIZE = 5;
-
-BasicSession::BasicSession(PacketInterface *lower)
-    : PacketInterface(remaining_packet_size(lower->get_max_packet_size(), HEADER_SIZE)), lower_(lower) {
-  this->stack_on_(lower, CAPABILITY_SESSION);
-  // Data lost by a reliability layer below must be sent again, as after a restart of the peer
-  if (lower->has_capability(CAPABILITY_RELIABILITY)) {
-    lower->add_on_session_state_callback([this](bool connected) {
-      if (!connected && this->connected_)
-        this->set_connected_(false);
-    });
-  }
-}
-
-void BasicSession::setup() {
-  if (this->lower_->get_max_packet_size() < KEEP_ALIVE_SIZE) {
-    this->mark_failed(LOG_STR("max_packet_size too small for the configured layers"));
-    return;
-  }
-  this->boot_id_ = random_uint32();
-#ifdef USE_BINARY_SENSOR
-  if (this->connected_sensor_ != nullptr)
-    this->connected_sensor_->publish_initial_state(false);
-#endif
-  this->lower_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
-  // A reliability layer below queues this until its link is up, so the peer hears of a restart straight away
-  this->send_keep_alive_();
-  this->set_interval(this->keep_alive_ms_, [this] { this->on_interval_(); });
-}
-
-void BasicSession::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Basic Session on '%s':\n"
-                "  Max Packet Size: %zu\n"
-                "  Keep Alive: %" PRIu32 "ms\n"
-                "  Timeout: %" PRIu32 "ms",
-                this->name_, this->max_packet_size_, this->keep_alive_ms_, this->timeout_ms_);
-#ifdef USE_BINARY_SENSOR
-  LOG_BINARY_SENSOR("  ", "Connected", this->connected_sensor_);
-#endif
-}
-
-bool BasicSession::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  if (this->is_failed())
-    return false;
-  uint8_t header = PACKET_TYPE_DATA;
-  PacketBuffer packet(&header, HEADER_SIZE, &data, nullptr, 0);
-  return this->lower_->send_to_interface(packet, meta_data);
-}
-
-void BasicSession::send_keep_alive_() {
-  uint8_t packet[KEEP_ALIVE_SIZE] = {
-      PACKET_TYPE_KEEP_ALIVE, static_cast<uint8_t>(this->boot_id_), static_cast<uint8_t>(this->boot_id_ >> 8),
-      static_cast<uint8_t>(this->boot_id_ >> 16), static_cast<uint8_t>(this->boot_id_ >> 24)};
-  if (!this->lower_->send_to_interface(PacketBuffer(packet, sizeof(packet)), {}))
-    ESP_LOGV(TAG, "%s: Lower layer did not accept keep-alive", this->name_);
-}
-
-void BasicSession::on_interval_() {
-  this->send_keep_alive_();
-  if (this->connected_ && App.get_loop_component_start_time() - this->last_receive_ms_ > this->timeout_ms_) {
-    ESP_LOGW(TAG, "%s: Peer not heard for %" PRIu32 "ms", this->name_, this->timeout_ms_);
-    this->set_connected_(false);
-  }
-}
-
-void BasicSession::set_connected_(bool connected) {
-  this->connected_ = connected;
-  ESP_LOGD(TAG, "%s: Session %s", this->name_, connected ? LOG_STR_LITERAL("connected") : LOG_STR_LITERAL("lost"));
-#ifdef USE_BINARY_SENSOR
-  if (this->connected_sensor_ != nullptr)
-    this->connected_sensor_->publish_state(connected);
-#endif
-  this->session_callback_.call(connected);
-}
-
-void BasicSession::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  // Lower layers deliver packets in one piece; the payload is passed up without copying
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "%s: Packet split across buffers is not supported", this->name_);
-    return;
-  }
-  auto packet = data.as_span();
-  if (packet.empty()) {
-    this->note_received_(false);
-    return;
-  }
-  uint8_t type = packet[0];
-  if (type == PACKET_TYPE_KEEP_ALIVE) {
-    if (packet.size() != KEEP_ALIVE_SIZE) {
-      ESP_LOGV(TAG, "%s: Keep-alive of %zu bytes dropped", this->name_, packet.size());
-      this->note_received_(false);
-      return;
-    }
-    uint32_t boot_id = encode_uint32(packet[4], packet[3], packet[2], packet[1]);
-    if (!this->peer_known_ || boot_id != this->peer_boot_id_) {
-      // Data may arrive before the first keep-alive, so only a changed id means a restart
-      if (this->connected_ && this->peer_known_) {
-        ESP_LOGD(TAG, "%s: Peer has restarted", this->name_);
-        this->set_connected_(false);
-      }
-      this->peer_boot_id_ = boot_id;
-      this->peer_known_ = true;
-      // Answer a new peer at once; it answers only if our id is new to it, so this cannot repeat
-      this->send_keep_alive_();
-    }
-  } else if (type != PACKET_TYPE_DATA) {
-    ESP_LOGV(TAG, "%s: Unknown packet type 0x%02X dropped", this->name_, type);
-    this->note_received_(false);
-    return;
-  }
-  this->note_received_(true);
-  this->last_receive_ms_ = App.get_loop_component_start_time();
-  if (!this->connected_)
-    this->set_connected_(true);
-  if (type == PACKET_TYPE_DATA)
-    this->on_receive_from_interface_(PacketBuffer(packet.data() + HEADER_SIZE, packet.size() - HEADER_SIZE), meta_data);
-}
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/basic_session.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_PACKET_INTERFACE_BASIC_SESSION
-#include "packet_interface.h"
-#ifdef USE_BINARY_SENSOR
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#endif
-
-namespace esphome::packet_interface {
-
-/**
- * A session layer that reports whether the peer can be reached.
- *
- * Every packet starts with a type byte. A data packet carries the payload of the layer above. A keep-alive packet
- * carries a random number chosen at boot, so that a restart of the peer is noticed even if it is quicker than the
- * timeout. A keep-alive is sent every keep_alive interval, and at once when a new peer is heard. The peer is
- * considered gone when nothing has been received from it for the timeout; this is checked every keep_alive interval.
- * A restart of the peer is reported as a disconnect followed by a connect. So is a reset of a reliability layer below,
- * which discards data: the session is reported lost, and connected again when the peer is next heard.
- */
-class BasicSession : public PacketInterface {
- public:
-  /// The packet type byte.
-  static constexpr size_t HEADER_SIZE = 1;
-
-  explicit BasicSession(PacketInterface *lower);
-
-  void setup() override;
-  void dump_config() override;
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
-
-  void set_keep_alive(uint32_t keep_alive_ms) { this->keep_alive_ms_ = keep_alive_ms; }
-  void set_session_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
-#ifdef USE_BINARY_SENSOR
-  void set_connected_sensor(binary_sensor::BinarySensor *sensor) { this->connected_sensor_ = sensor; }
-#endif
-
-  bool is_connected() const { return this->connected_; }
-
- protected:
-  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
-  void on_interval_();
-  void send_keep_alive_();
-  void set_connected_(bool connected);
-
-  PacketInterface *lower_;
-#ifdef USE_BINARY_SENSOR
-  binary_sensor::BinarySensor *connected_sensor_{nullptr};
-#endif
-  uint32_t keep_alive_ms_{10000};
-  uint32_t timeout_ms_{30000};
-  uint32_t last_receive_ms_{0};
-  uint32_t boot_id_{0};
-  uint32_t peer_boot_id_{0};
-  bool peer_known_{false};
-  bool connected_{false};
-};
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/hdlc_reliability.cpp

@@ -1,365 +0,0 @@
-#include "hdlc_reliability.h"
-#ifdef USE_PACKET_INTERFACE_HDLC
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.hdlc");
-
-static constexpr uint32_t RETRANSMIT_TIMER_ID = 0;
-static constexpr uint32_t ACK_TIMER_ID = 1;
-static constexpr uint32_t SEND_RETRY_TIMER_ID = 2;
-// A frame or acknowledgement the lower layer refused, for example while a radio was receiving, is sent again after this
-static constexpr uint32_t SEND_RETRY_MS = 50;
-// SABM is repeated at this interval, or the timeout if longer, until the peer answers
-static constexpr uint32_t RESET_INTERVAL_MS = 1000;
-
-// Control byte formats, with the poll/final bit (0x10) ignored
-static constexpr uint8_t POLL_FINAL_BIT = 0x10;
-static constexpr uint8_t SUPERVISORY_FRAME = 0x01;
-static constexpr uint8_t SUPERVISORY_RR = 0x00;
-static constexpr uint8_t SUPERVISORY_REJ = 0x02;
-static constexpr uint8_t UNNUMBERED_SABM = 0x2F;
-static constexpr uint8_t UNNUMBERED_UA = 0x63;
-
-static uint16_t frame_crc(uint8_t control, const uint8_t *payload, size_t length) {
-  uint16_t crc = crc16(&control, 1);
-  return crc16(payload, length, crc);
-}
-
-HdlcReliability::HdlcReliability(PacketInterface *lower)
-    : PacketInterface(remaining_packet_size(lower->get_max_packet_size(), FRAME_OVERHEAD)), lower_(lower) {
-  this->stack_on_(lower, CAPABILITY_RELIABILITY);
-}
-
-void HdlcReliability::setup() {
-  if (this->max_packet_size_ == 0) {
-    this->mark_failed(LOG_STR("max_packet_size too small for the configured layers"));
-    return;
-  }
-  RAMAllocator<uint8_t> allocator;
-  this->tx_slots_ = allocator.allocate(size_t{this->max_queue_length_} * this->max_packet_size_);
-  if (this->tx_slots_ == nullptr) {
-    this->mark_failed(LOG_STR("Not enough memory for the send queue"));
-    return;
-  }
-  this->lower_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
-}
-
-void HdlcReliability::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "HDLC Reliability on '%s':\n"
-                "  Max Packet Size: %zu\n"
-                "  Timeout: %" PRIu32 "ms\n"
-                "  Ack Delay: %" PRIu32 "ms\n"
-                "  Max Queue Length: %u\n"
-                "  Max Retries: %u",
-                this->name_, this->max_packet_size_, this->timeout_ms_, this->ack_delay_ms_, this->max_queue_length_,
-                this->max_retries_);
-}
-
-void HdlcReliability::loop() {
-  // Disabled first, as sending may deliver a reply to this layer and request the loop again
-  this->disable_loop();
-  if (this->state_ == LinkState::LINK_STATE_RESET_PENDING) {
-    this->state_ = LinkState::LINK_STATE_RESETTING;
-    this->start_timer_();
-    this->send_frame_(UNNUMBERED_SABM, nullptr, 0);
-  }
-  if (this->state_ != LinkState::LINK_STATE_CONNECTED)
-    return;
-  // Queued frames go first, as each carries the acknowledgement
-  if (this->send_pending_() && this->ack_due_ && !this->send_supervisory_(SUPERVISORY_RR))
-    this->retry_send_();
-}
-
-void HdlcReliability::retry_send_() {
-  this->set_timeout(SEND_RETRY_TIMER_ID, SEND_RETRY_MS, [this]() { this->request_loop_(); });
-}
-
-void HdlcReliability::owe_ack_(bool now) {
-  if (now || this->ack_delay_ms_ == 0) {
-    this->ack_due_ = true;
-    this->request_loop_();
-  } else if (!this->ack_pending_) {
-    // Waiting lets one acknowledgement cover several frames, or a reply carry it
-    this->set_timeout(ACK_TIMER_ID, this->ack_delay_ms_, [this]() {
-      this->ack_due_ = true;
-      this->request_loop_();
-    });
-  }
-  this->ack_pending_ = true;
-}
-
-void HdlcReliability::ack_sent_() {
-  this->ack_pending_ = false;
-  this->ack_due_ = false;
-  this->cancel_timeout(ACK_TIMER_ID);
-}
-
-void HdlcReliability::request_loop_() { this->enable_loop(); }
-
-bool HdlcReliability::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  if (this->tx_slots_ == nullptr)
-    return false;
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  uint8_t outstanding = this->outstanding_();
-  if (outstanding >= this->max_queue_length_) {
-    if (this->state_ == LinkState::LINK_STATE_CONNECTED) {
-      ESP_LOGV(TAG, "%s: Send queue full", this->name_);
-    } else if (!this->reset_wait_logged_) {
-      // Once for each reset; the layers above keep trying while the peer is away
-      this->reset_wait_logged_ = true;
-      ESP_LOGD(TAG, "%s: Send queue full, waiting for the peer to answer the link reset", this->name_);
-    }
-    return false;
-  }
-  uint8_t seq = this->vs_;
-  data.copy_to(this->slot_(seq), size);
-  this->tx_lengths_[this->slot_index_(seq)] = size;
-  this->vs_ = (seq + 1) & 7;
-  // While the link is being reset, the frame waits in the queue and is sent when UA arrives
-  if (this->state_ == LinkState::LINK_STATE_CONNECTED) {
-    this->send_pending_();
-    if (outstanding == 0)
-      this->start_timer_();
-  }
-  return true;
-}
-
-bool HdlcReliability::send_frame_(uint8_t control, const uint8_t *payload, size_t length) {
-  uint16_t crc = frame_crc(control, payload, length);
-  uint8_t trailer[2] = {static_cast<uint8_t>(crc), static_cast<uint8_t>(crc >> 8)};
-  PacketBuffer body(payload, length);
-  PacketBuffer frame(&control, 1, length != 0 ? &body : nullptr, trailer, sizeof(trailer));
-  if (this->lower_->send_to_interface(frame, {}))
-    return true;
-  ESP_LOGV(TAG, "%s: Lower layer did not accept frame 0x%02X", this->name_, control);
-  return false;
-}
-
-bool HdlcReliability::send_supervisory_(uint8_t type) {
-  if (!this->send_frame_(SUPERVISORY_FRAME | (type << 2) | (this->vr_ << 5), nullptr, 0))
-    return false;
-  this->ack_sent_();
-  return true;
-}
-
-// Sends the next queued frame not yet sent, and returns true if none are left. One frame per loop pass lets other
-// components run between frames: on a radio, sending blocks, and the peer's frames are received in between. If the
-// lower layer refuses the frame, it is sent again shortly.
-bool HdlcReliability::send_pending_() {
-  if (this->vn_ == this->vs_)
-    return true;
-  uint8_t control = (this->vn_ << 1) | (this->vr_ << 5);
-  if (!this->send_frame_(control, this->slot_(this->vn_), this->tx_lengths_[this->slot_index_(this->vn_)])) {
-    this->retry_send_();
-    return false;
-  }
-  // Every I-frame carries an acknowledgement, so a pending RR is no longer needed
-  this->ack_sent_();
-  this->vn_ = (this->vn_ + 1) & 7;
-  if (this->vn_ == this->vs_)
-    return true;
-  this->request_loop_();
-  return false;
-}
-
-void HdlcReliability::resend_outstanding_() {
-  this->vn_ = this->va_;
-  this->send_pending_();
-}
-
-void HdlcReliability::start_timer_() {
-  uint32_t interval = this->timeout_ms_;
-  if (this->state_ != LinkState::LINK_STATE_CONNECTED && interval < RESET_INTERVAL_MS)
-    interval = RESET_INTERVAL_MS;
-  // Up to a quarter longer at random, so devices whose frames collided on a shared channel do not resend together
-  interval += random_uint32() % (interval / 4 + 1);
-  this->set_timeout(RETRANSMIT_TIMER_ID, interval, [this]() { this->on_timeout_(); });
-}
-
-void HdlcReliability::on_timeout_() {
-  if (this->state_ != LinkState::LINK_STATE_CONNECTED) {
-    // Counted up to max_retries_ only, so the warning is logged once until the link comes up
-    if (this->retries_ < this->max_retries_) {
-      this->retries_++;
-      if (this->retries_ == this->max_retries_) {
-        ESP_LOGW(TAG, "%s: No answer to the link reset after %u tries; check that the peer has a reliability layer",
-                 this->name_, this->max_retries_);
-      }
-    }
-    this->send_frame_(UNNUMBERED_SABM, nullptr, 0);
-    this->start_timer_();
-    return;
-  }
-  if (this->outstanding_() == 0)
-    return;
-  if (this->retries_ == this->max_retries_) {
-    ESP_LOGW(TAG, "%s: No acknowledgement after %u retries, resetting link", this->name_, this->max_retries_);
-    this->start_reset_();
-    return;
-  }
-  this->retries_++;
-  ESP_LOGV(TAG, "%s: Timeout, resending %u frames", this->name_, this->outstanding_());
-  this->resend_outstanding_();
-  this->start_timer_();
-}
-
-// Unacknowledged frames are discarded; frames queued from now on are numbered from 0 and sent once the link is up.
-// Resetting a connected link can lose data both ways, which is reported to the layers above.
-void HdlcReliability::start_reset_() {
-  bool was_connected = this->state_ == LinkState::LINK_STATE_CONNECTED;
-  this->state_ = LinkState::LINK_STATE_RESET_PENDING;
-  this->va_ = this->vs_ = this->vn_ = 0;
-  this->head_ = 0;
-  this->vr_ = 0;
-  this->retries_ = 0;
-  this->rej_sent_ = false;
-  this->ack_sent_();
-  this->cancel_timeout(RETRANSMIT_TIMER_ID);
-  this->request_loop_();
-  if (was_connected)
-    this->session_callback_.call(false);
-}
-
-void HdlcReliability::link_up_() {
-  ESP_LOGD(TAG, "%s: Link connected", this->name_);
-  this->state_ = LinkState::LINK_STATE_CONNECTED;
-  this->reset_wait_logged_ = false;
-  this->peer_frame_seen_ = false;
-  this->retries_ = 0;
-  this->cancel_timeout(RETRANSMIT_TIMER_ID);
-  if (this->outstanding_() != 0) {
-    this->resend_outstanding_();
-    this->start_timer_();
-  }
-}
-
-void HdlcReliability::process_ack_(uint8_t nr) {
-  uint8_t acked = (nr - this->va_) & 7;
-  if (acked > this->outstanding_()) {
-    ESP_LOGV(TAG, "%s: Ignoring invalid N(R) %u", this->name_, nr);
-    return;
-  }
-  if (acked == 0)
-    return;
-  // The peer may have had frames that were refused when last resent
-  if (acked > ((this->vn_ - this->va_) & 7))
-    this->vn_ = nr;
-  this->head_ = (this->head_ + acked) % this->max_queue_length_;
-  this->va_ = nr;
-  this->retries_ = 0;
-  if (this->outstanding_() == 0) {
-    this->cancel_timeout(RETRANSMIT_TIMER_ID);
-  } else {
-    this->start_timer_();
-  }
-}
-
-void HdlcReliability::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  // Lower layers deliver packets in one piece; the payload is passed up without copying
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "%s: Packet split across buffers is not supported", this->name_);
-    return;
-  }
-  auto frame = data.as_span();
-  if (frame.size() < FRAME_OVERHEAD) {
-    this->note_received_(false);
-    return;
-  }
-  size_t length = frame.size() - FRAME_OVERHEAD;
-  uint8_t control = frame[0];
-  const uint8_t *payload = frame.data() + 1;
-  uint16_t crc = frame[length + 1] | (frame[length + 2] << 8);
-  if (frame_crc(control, payload, length) != crc) {
-    ESP_LOGV(TAG, "%s: CRC error, frame dropped", this->name_);
-    this->note_received_(false);
-    return;
-  }
-  // The peer's packets may only be larger if it has a larger max_packet_size, which the layers above cannot take
-  if (length > this->max_packet_size_) {
-    if (!this->oversize_warned_) {
-      this->oversize_warned_ = true;
-      ESP_LOGW(TAG,
-               "%s: Frame of %zu bytes is larger than %zu, dropped; check that both devices use the same "
-               "max_packet_size",
-               this->name_, length, this->max_packet_size_);
-    } else {
-      ESP_LOGV(TAG, "%s: Frame of %zu bytes is larger than %zu, dropped", this->name_, length, this->max_packet_size_);
-    }
-    this->note_received_(false);
-    return;
-  }
-  this->note_received_(true);
-
-  uint8_t command = control & ~POLL_FINAL_BIT;
-  if (command == UNNUMBERED_SABM) {
-    // A peer that has not heard our UA repeats its SABM, and cannot have sent a numbered frame meanwhile; answering
-    // again keeps this side connected, and the queued frames, instead of treating the repeat as a restart.
-    if (this->state_ == LinkState::LINK_STATE_CONNECTED && this->peer_frame_seen_) {
-      // The peer has restarted, so frames it has not acknowledged are lost
-      ESP_LOGD(TAG, "%s: Link reset by peer", this->name_);
-      this->start_reset_();
-    }
-    this->vr_ = 0;
-    this->rej_sent_ = false;
-    this->send_frame_(UNNUMBERED_UA, nullptr, 0);
-    // Both sides now start from 0, so the link is up even if our own SABM is unanswered
-    this->link_up_();
-    return;
-  }
-  if (command == UNNUMBERED_UA) {
-    if (this->state_ == LinkState::LINK_STATE_RESETTING)
-      this->link_up_();
-    return;
-  }
-  // Numbered frames are ignored until the link is reset; the peer answers our SABM first
-  if (this->state_ != LinkState::LINK_STATE_CONNECTED)
-    return;
-  this->peer_frame_seen_ = true;
-
-  uint8_t nr = control >> 5;
-  if ((control & 1) == 0) {
-    this->process_ack_(nr);
-    this->receive_info_(control, payload, length, meta_data);
-    return;
-  }
-  if ((control & 3) != SUPERVISORY_FRAME)
-    return;
-  this->process_ack_(nr);
-  if (((control >> 2) & 3) == SUPERVISORY_REJ && this->outstanding_() != 0) {
-    ESP_LOGV(TAG, "%s: Peer rejected from %u", this->name_, nr);
-    this->resend_outstanding_();
-    this->start_timer_();
-  }
-}
-
-void HdlcReliability::receive_info_(uint8_t control, const uint8_t *payload, size_t length,
-                                    const PacketMetaData &meta_data) {
-  uint8_t ns = (control >> 1) & 7;
-  if (ns != this->vr_) {
-    // A gap or a duplicate; ask once for a resend from the expected frame, then just acknowledge at once
-    if (!this->rej_sent_) {
-      this->rej_sent_ = this->send_supervisory_(SUPERVISORY_REJ);
-      if (this->rej_sent_)
-        return;
-    }
-    this->owe_ack_(true);
-    return;
-  }
-  this->vr_ = (this->vr_ + 1) & 7;
-  this->rej_sent_ = false;
-  // The acknowledgement is sent from loop(), so a reply sent from the callback can carry it instead
-  this->owe_ack_(false);
-  this->on_receive_from_interface_(PacketBuffer(payload, length), meta_data);
-}
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/hdlc_reliability.h

@@ -1,99 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_PACKET_INTERFACE_HDLC
-#include <array>
-
-#include "packet_interface.h"
-
-namespace esphome::packet_interface {
-
-/**
- * A reliability layer that delivers packets in order, without loss or duplicates, between two peers.
- *
- * It follows HDLC asynchronous balanced mode, with sequence numbers modulo 8 and go-back-N retransmission:
- * - I-frames carry a payload, the sequence number N(S) and an acknowledgement N(R) of the peer's frames.
- * - RR frames acknowledge without a payload; REJ frames ask the peer to resend from N(R).
- * - SABM resets both peers' sequence numbers, and UA answers it.
- *
- * Each frame is the HDLC control byte, the payload, then a CRC-16 of both in little endian order.
- * Unacknowledged frames are resent after the timeout; after max_retries the link is reset.
- */
-class HdlcReliability : public PacketInterface {
- public:
-  /// Most frames that can be unacknowledged at once, set by the 3 bit sequence numbers.
-  static constexpr uint8_t MAX_WINDOW = 7;
-  /// Control byte plus CRC-16.
-  static constexpr size_t FRAME_OVERHEAD = 3;
-
-  explicit HdlcReliability(PacketInterface *lower);
-
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
-  /// No room while the layer has no send queue: before setup(), or when setup() failed.
-  size_t get_send_capacity() const override {
-    return this->tx_slots_ == nullptr ? 0 : this->max_queue_length_ - this->outstanding_();
-  }
-
-  void set_ack_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
-  void set_ack_delay(uint32_t ack_delay_ms) { this->ack_delay_ms_ = ack_delay_ms; }
-  void set_max_queue_length(uint8_t length) { this->max_queue_length_ = length; }
-  void set_max_retries(uint8_t retries) { this->max_retries_ = retries; }
-
-  bool is_connected() const { return this->state_ == LinkState::LINK_STATE_CONNECTED; }
-
- protected:
-  enum class LinkState : uint8_t {
-    LINK_STATE_RESET_PENDING,  // SABM to be sent from loop()
-    LINK_STATE_RESETTING,      // SABM sent, waiting for UA
-    LINK_STATE_CONNECTED,
-  };
-
-  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
-  void receive_info_(uint8_t control, const uint8_t *payload, size_t length, const PacketMetaData &meta_data);
-  bool send_frame_(uint8_t control, const uint8_t *payload, size_t length);
-  bool send_supervisory_(uint8_t type);
-  bool send_pending_();
-  void resend_outstanding_();
-  void retry_send_();
-  /// An RR is owed: at once, or after the ack delay unless an I-frame carries it first.
-  void owe_ack_(bool now);
-  void ack_sent_();
-  void process_ack_(uint8_t nr);
-  void on_timeout_();
-  void start_reset_();
-  void link_up_();
-  void start_timer_();
-  void request_loop_();
-  uint8_t outstanding_() const { return (this->vs_ - this->va_) & 7; }
-  uint8_t slot_index_(uint8_t seq) const { return (this->head_ + ((seq - this->va_) & 7)) % this->max_queue_length_; }
-  uint8_t *slot_(uint8_t seq) { return this->tx_slots_ + this->slot_index_(seq) * this->max_packet_size_; }
-
-  PacketInterface *lower_;
-  // max_queue_length_ slots of max_packet_size_ bytes, a ring starting at head_ which holds frame va_; allocated in
-  // setup() and never freed
-  uint8_t *tx_slots_{nullptr};
-  std::array<uint16_t, MAX_WINDOW> tx_lengths_{};  // indexed like the slots
-  uint32_t timeout_ms_{200};
-  uint32_t ack_delay_ms_{0};
-  uint8_t max_queue_length_{4};
-  uint8_t max_retries_{5};
-  uint8_t retries_{0};
-  uint8_t head_{0};
-  uint8_t vs_{0};  // sequence number of the next new frame
-  uint8_t vn_{0};  // next frame to send; frames from va_ up to it have been sent
-  uint8_t va_{0};  // oldest unacknowledged frame
-  uint8_t vr_{0};  // next frame expected from the peer
-  LinkState state_{LinkState::LINK_STATE_RESET_PENDING};
-  bool ack_pending_{false};  // an RR is owed
-  bool ack_due_{false};      // and should be sent now
-  bool rej_sent_{false};
-  bool peer_frame_seen_{false};  // a numbered frame has arrived since the link came up
-  bool oversize_warned_{false};
-  bool reset_wait_logged_{false};  // the queue filled while waiting for this reset to be answered
-};
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/layers/__init__.py

@@ -1,258 +0,0 @@
-"""The kinds of layer that can be stacked on a packet interface, and the registry of their implementations.
-
-Each module in this package implements one layer type and registers it with its kind, for example:
-
-    @RELIABILITY.register("hdlc", schema=HDLC_SCHEMA, single_peer=lambda config: True)
-    async def build_hdlc(config: ConfigType, lower: MockObj) -> MockObj:
-        ...
-
-The packet_interface component imports every module here before it builds its schemas, so a new layer type needs
-only a new module. The kinds, and the order in which they are stacked, are fixed here.
-"""
-
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
-from typing import Any
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_ENCRYPTION, CONF_FRAGMENTATION, CONF_KEY, CONF_TYPE
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-packet_interface_ns = cg.esphome_ns.namespace("packet_interface")
-PacketInterface = packet_interface_ns.class_("PacketInterface", cg.Component)
-
-CONF_ADDRESSING = "addressing"
-CONF_DESTINATION = "destination"
-CONF_PEERS = "peers"
-CONF_RELIABILITY = "reliability"
-CONF_SESSION = "session"
-
-BROADCAST_ADDRESS = 0xFFFF
-
-# Builds a layer above lower and returns it. An addressing layer instead returns a list of (port, config) pairs, one
-# for each stack it carries, where config holds the layers for that stack, or is None for the layers on the link.
-LayerBuilder = Callable[[ConfigType, MockObj], Awaitable[Any]]
-
-
-def _never(config: ConfigType) -> bool:
-    return False
-
-
-def _nothing(config: ConfigType) -> list[str]:
-    return []
-
-
-def _same_size(config: ConfigType, size: int) -> int:
-    return size
-
-
-def _no_limit(config: ConfigType) -> int | None:
-    return None
-
-
-def _fits(config: ConfigType, size: int, capacity: int | None) -> None:
-    """Accept any layer below."""
-
-
-@dataclass(frozen=True)
-class LayerType:
-    """One implementation of a kind of layer."""
-
-    # Returns the schema; called once every layer type is registered, as some schemas contain other layers
-    schema_factory: Callable[[], Any]
-    build: LayerBuilder
-    # True if this configuration keeps state for one peer, so cannot be used with broadcast addressing
-    single_peer: Callable[[ConfigType], bool]
-    # True if this configuration works only when the peer sends packets back, which a session layer makes sure of
-    needs_session: Callable[[ConfigType], bool]
-    # The components this configuration needs loaded
-    auto_load: Callable[[ConfigType], list[str]]
-    # The largest packet this configuration takes, from the largest that the layer below takes, as the C++ works it out
-    packet_size: Callable[[ConfigType, int], int]
-    # How many packets this configuration takes at once, or None for no limit
-    send_capacity: Callable[[ConfigType], int | None]
-    # Raises cv.Invalid if this configuration cannot work above a layer with this packet size and send capacity
-    check_lower: Callable[[ConfigType, int, int | None], None]
-
-
-class LayerKind:
-    """A kind of layer, such as encryption, with the types that implement it."""
-
-    def __init__(
-        self, key: str, default_type: str, shorthand: str | None = None
-    ) -> None:
-        self.key = key
-        self.default_type = default_type
-        # The option that a plain string value sets, as in `encryption: my key`
-        self.shorthand = shorthand
-        self.types: dict[str, LayerType] = {}
-        # Set once the schema is built, as types registered after that would not be in it
-        self.frozen = False
-
-    def register(
-        self,
-        name: str,
-        *,
-        schema: Any = None,
-        schema_factory: Callable[[], Any] | None = None,
-        single_peer: Callable[[ConfigType], bool] = _never,
-        needs_session: Callable[[ConfigType], bool] = _never,
-        auto_load: Callable[[ConfigType], list[str]] = _nothing,
-        packet_size: Callable[[ConfigType, int], int] = _same_size,
-        send_capacity: Callable[[ConfigType], int | None] = _no_limit,
-        check_lower: Callable[[ConfigType, int, int | None], None] = _fits,
-    ) -> Callable[[LayerBuilder], LayerBuilder]:
-        """Register a type with its schema, or with a function returning a schema that contains other layers."""
-
-        def fixed_schema() -> Any:
-            return schema
-
-        def decorator(build: LayerBuilder) -> LayerBuilder:
-            if self.frozen:
-                raise ValueError(
-                    f"{self.key} layer type '{name}' is registered after the schemas were built; register it "
-                    "before the packet_interface component is imported"
-                )
-            if name in self.types:
-                raise ValueError(
-                    f"{self.key} layer type '{name}' is already registered"
-                )
-            self.types[name] = LayerType(
-                schema_factory or fixed_schema,
-                build,
-                single_peer,
-                needs_session,
-                auto_load,
-                packet_size,
-                send_capacity,
-                check_lower,
-            )
-            return build
-
-        return decorator
-
-    def _expand(self, value: Any) -> Any:
-        """Allow a layer to be enabled with no options, as in `reliability:`, or with its shorthand."""
-        if value is None:
-            return {}
-        if self.shorthand is not None and isinstance(value, str):
-            return {self.shorthand: value}
-        return value
-
-    def schema(self) -> Callable[[Any], ConfigType]:
-        """The schema for this kind; no type can be registered after this."""
-        self.frozen = True
-        return cv.All(
-            self._expand,
-            cv.typed_schema(
-                {name: layer.schema_factory() for name, layer in self.types.items()},
-                default_type=self.default_type,
-            ),
-        )
-
-    def get_type(self, config: ConfigType) -> LayerType:
-        return self.types[config[CONF_TYPE]]
-
-
-# An addressing type's configuration has either a destination or a list of peers, each with an id, a destination
-# and its own layers.
-ADDRESSING = LayerKind(CONF_ADDRESSING, "basic")
-ENCRYPTION = LayerKind(CONF_ENCRYPTION, "xxtea", shorthand=CONF_KEY)
-RELIABILITY = LayerKind(CONF_RELIABILITY, "hdlc")
-FRAGMENTATION = LayerKind(CONF_FRAGMENTATION, "basic")
-SESSION = LayerKind(CONF_SESSION, "basic")
-# The kinds stacked above the link, or above each port of an addressing layer, from the bottom up
-STACK_ORDER = (ENCRYPTION, RELIABILITY, FRAGMENTATION, SESSION)
-
-
-def stack_schema() -> dict:
-    """Schema entries for the layers of one stack; call only once all layer types are registered."""
-    return {cv.Optional(kind.key): kind.schema() for kind in STACK_ORDER}
-
-
-def layer_needing_session(config: ConfigType) -> str | None:
-    """The key of the first layer in this stack that needs packets back from the peer, if any."""
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is not None and kind.get_type(
-            layer
-        ).needs_session(layer):
-            return kind.key
-    return None
-
-
-def check_session(config: ConfigType) -> None:
-    """Layers that need packets back from the peer need a session layer, whose keep-alives send them."""
-    if CONF_SESSION not in config and (key := layer_needing_session(config)):
-        raise cv.Invalid(
-            f"This '{key}' needs packets from the peer, so it needs a '{CONF_SESSION}' layer, whose "
-            "keep-alives make sure they are sent",
-            path=[key],
-        )
-
-
-def check_single_peer(config: ConfigType, destination: int) -> None:
-    """Layers that keep state for one peer need a destination other than broadcast."""
-    if destination != BROADCAST_ADDRESS:
-        return
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is not None and kind.get_type(
-            layer
-        ).single_peer(layer):
-            raise cv.Invalid(
-                f"This '{kind.key}' works between two devices only, so it needs a '{CONF_DESTINATION}' other than "
-                "broadcast",
-                path=[kind.key],
-            )
-
-
-def remaining_packet_size(size: int, used: int) -> int:
-    return max(size - used, 0)
-
-
-def check_packet_sizes(config: ConfigType, size: int) -> None:
-    """Check each layer in config against the layer below it; size is the largest packet that the stack sits on takes."""
-    capacity = None
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is None:
-            continue
-        layer_type = kind.get_type(layer)
-        try:
-            layer_type.check_lower(layer, size, capacity)
-        except cv.Invalid as err:
-            err.prepend([kind.key])
-            raise
-        size = layer_type.packet_size(layer, size)
-        capacity = layer_type.send_capacity(layer)
-
-
-def check_broadcast_link(config: ConfigType) -> None:
-    """On a link that every device hears, layers that keep state for one peer need an addressing layer."""
-    if CONF_ADDRESSING in config:
-        return
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is not None and kind.get_type(
-            layer
-        ).single_peer(layer):
-            raise cv.Invalid(
-                f"This '{kind.key}' works between two devices only, but every device hears this link, so it needs "
-                f"'{CONF_ADDRESSING}' with a '{CONF_DESTINATION}'",
-                path=[kind.key],
-            )
-
-
-def stack_auto_load(config: ConfigType) -> set[str]:
-    """The components that the layers configured in config need loaded."""
-    loads: set[str] = set()
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is not None:
-            loads.update(kind.get_type(layer).auto_load(layer))
-    return loads
-
-
-async def build_stack(config: ConfigType, lower: MockObj) -> None:
-    """Create the layers configured in config, from the bottom up, above lower."""
-    for kind in STACK_ORDER:
-        if (layer := config.get(kind.key)) is not None:
-            lower = await kind.get_type(layer).build(layer, lower)

esphome/components/packet_interface/layers/basic_addressing.py

@@ -1,132 +0,0 @@
-"""Addressing layer with 16-bit addresses, carrying one stack of layers or one for each of several peers."""
-
-from typing import Any
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_ADDRESS, CONF_ID
-from esphome.core import ID
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import (
-    ADDRESSING,
-    BROADCAST_ADDRESS,
-    CONF_DESTINATION,
-    CONF_PEERS,
-    PacketInterface,
-    check_session,
-    check_single_peer,
-    packet_interface_ns,
-    remaining_packet_size,
-    stack_schema,
-)
-
-CONF_PORT_ID = "port_id"
-
-# The destination and source addresses
-HEADER_SIZE = 4
-
-BasicAddressing = packet_interface_ns.class_("BasicAddressing", cg.Component)
-AddressingPort = packet_interface_ns.class_("AddressingPort", PacketInterface)
-
-_request_port_slot = cg.slot_counter("PACKET_INTERFACE_ADDRESSING_PORT_COUNT")
-
-
-def _destination(value: Any) -> int:
-    """A device address, or broadcast."""
-    if isinstance(value, str) and value.lower() == "broadcast":
-        return BROADCAST_ADDRESS
-    return cv.hex_int_range(1, BROADCAST_ADDRESS)(value)
-
-
-def _validate_peer(config: ConfigType) -> ConfigType:
-    check_session(config)
-    check_single_peer(config, config[CONF_DESTINATION])
-    return config
-
-
-def _unique_destinations(peers: list[ConfigType]) -> list[ConfigType]:
-    destinations = [peer[CONF_DESTINATION] for peer in peers]
-    if len(set(destinations)) != len(destinations):
-        raise cv.Invalid("Each peer must have a different destination")
-    return peers
-
-
-def _not_own_address(config: ConfigType) -> ConfigType:
-    """Packets from this device's own address are dropped as echoes, so it cannot be a destination."""
-    address = config[CONF_ADDRESS]
-    if config.get(CONF_DESTINATION) == address:
-        raise cv.Invalid(
-            "Must not be this device's own address", path=[CONF_DESTINATION]
-        )
-    for index, peer in enumerate(config.get(CONF_PEERS, [])):
-        if peer[CONF_DESTINATION] == address:
-            raise cv.Invalid(
-                "Must not be this device's own address",
-                path=[CONF_PEERS, index, CONF_DESTINATION],
-            )
-    return config
-
-
-# A function, as each peer holds the other layers, whose schemas exist only once every layer type is registered
-def _basic_addressing_schema() -> cv.Schema:
-    peer_schema = cv.All(
-        cv.Schema(
-            {
-                cv.Required(CONF_ID): cv.declare_id(AddressingPort),
-                cv.Required(CONF_DESTINATION): _destination,
-                **stack_schema(),
-            }
-        ),
-        _validate_peer,
-    )
-    return cv.All(
-        cv.Schema(
-            {
-                cv.GenerateID(): cv.declare_id(BasicAddressing),
-                cv.GenerateID(CONF_PORT_ID): cv.declare_id(AddressingPort),
-                cv.Required(CONF_ADDRESS): cv.hex_int_range(1, BROADCAST_ADDRESS - 1),
-                cv.Optional(CONF_DESTINATION): _destination,
-                cv.Optional(CONF_PEERS): cv.All(
-                    cv.ensure_list(peer_schema), cv.Length(min=1), _unique_destinations
-                ),
-            }
-        ).extend(cv.COMPONENT_SCHEMA),
-        cv.has_at_most_one_key(CONF_DESTINATION, CONF_PEERS),
-        _not_own_address,
-    )
-
-
-async def _new_port(
-    port_id: ID, addressing: MockObj, destination: int, only_port: bool
-) -> MockObj:
-    _request_port_slot(str(addressing))
-    port = cg.new_Pvariable(port_id, addressing, destination, only_port)
-    await cg.register_component(port, {})
-    return port
-
-
-@ADDRESSING.register(
-    "basic",
-    schema_factory=_basic_addressing_schema,
-    packet_size=lambda config, size: remaining_packet_size(size, HEADER_SIZE),
-)
-async def build_basic_addressing(
-    config: ConfigType, link: MockObj
-) -> list[tuple[MockObj, ConfigType | None]]:
-    cg.add_define("USE_PACKET_INTERFACE_BASIC_ADDRESSING")
-    hub = cg.new_Pvariable(config[CONF_ID], link, config[CONF_ADDRESS])
-    await cg.register_component(hub, config)
-    if (peers := config.get(CONF_PEERS)) is None:
-        port = await _new_port(
-            config[CONF_PORT_ID], hub, config[CONF_DESTINATION], True
-        )
-        return [(port, None)]
-    stacks = []
-    # Each peer has its own stack, named after the peer for logs and saved preferences
-    for peer in peers:
-        port = await _new_port(peer[CONF_ID], hub, peer[CONF_DESTINATION], False)
-        cg.add(port.set_name(peer[CONF_ID].id))
-        stacks.append((port, peer))
-    return stacks

esphome/components/packet_interface/layers/basic_fragmentation.py

@@ -1,56 +0,0 @@
-"""Fragmentation layer that splits packets larger than the layers below allow, and joins them again."""
-
-import math
-
-import esphome.codegen as cg
-from esphome.components.const import CONF_MAX_PACKET_SIZE
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import FRAGMENTATION, PacketInterface, packet_interface_ns
-
-# The packet number, and the fragment's index with the flag on the last fragment
-HEADER_SIZE = 2
-MAX_FRAGMENTS = 128
-
-BasicFragmentation = packet_interface_ns.class_("BasicFragmentation", PacketInterface)
-
-BASIC_FRAGMENTATION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(BasicFragmentation),
-        # The packet being joined is held in a buffer of this size
-        cv.Optional(CONF_MAX_PACKET_SIZE, default=1024): cv.int_range(16, 16384),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-def _check_lower(config: ConfigType, size: int, capacity: int | None) -> None:
-    """The largest packet must fit in the fragments that the layer below can take at once."""
-    fragment_size = size - HEADER_SIZE
-    if fragment_size <= 0:
-        raise cv.Invalid("The layers below leave no room for fragments")
-    fragments = max(1, math.ceil(config[CONF_MAX_PACKET_SIZE] / fragment_size))
-    limit = MAX_FRAGMENTS if capacity is None else min(MAX_FRAGMENTS, capacity)
-    if fragments > limit:
-        raise cv.Invalid(
-            f"A packet of {config[CONF_MAX_PACKET_SIZE]} bytes needs {fragments} fragments of {fragment_size} bytes, "
-            f"but at most {limit} can be sent at once",
-            path=[CONF_MAX_PACKET_SIZE],
-        )
-
-
-# Fragments from different devices are told apart by the addressing layer's source address, so of two devices sending
-# fragmented packets at once, one still gets through; without addressing, the receiver can drop both
-@FRAGMENTATION.register(
-    "basic",
-    schema=BASIC_FRAGMENTATION_SCHEMA,
-    packet_size=lambda config, size: config[CONF_MAX_PACKET_SIZE],
-    check_lower=_check_lower,
-)
-async def build_basic_fragmentation(config: ConfigType, lower: MockObj) -> MockObj:
-    cg.add_define("USE_PACKET_INTERFACE_BASIC_FRAGMENTATION")
-    var = cg.new_Pvariable(config[CONF_ID], lower, config[CONF_MAX_PACKET_SIZE])
-    await cg.register_component(var, config)
-    return var

esphome/components/packet_interface/layers/basic_session.py

@@ -1,71 +0,0 @@
-"""Session layer that sends keep-alives and reports whether the peer can be reached."""
-
-import esphome.codegen as cg
-from esphome.components import binary_sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BINARY_SENSOR,
-    CONF_ID,
-    CONF_TIMEOUT,
-    DEVICE_CLASS_CONNECTIVITY,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-)
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import SESSION, PacketInterface, packet_interface_ns
-
-CONF_KEEP_ALIVE = "keep_alive"
-
-BasicSession = packet_interface_ns.class_("BasicSession", PacketInterface)
-
-
-def _session_timeout(config: ConfigType) -> ConfigType:
-    """Default the timeout to three keep-alive intervals, and require it to be longer than one."""
-    keep_alive = config[CONF_KEEP_ALIVE].total_milliseconds
-    if (timeout := config.get(CONF_TIMEOUT)) is None:
-        config[CONF_TIMEOUT] = cv.positive_time_period_milliseconds(
-            f"{keep_alive * 3}ms"
-        )
-    elif timeout.total_milliseconds <= keep_alive:
-        raise cv.Invalid("Must be longer than keep_alive", path=[CONF_TIMEOUT])
-    return config
-
-
-BASIC_SESSION_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(BasicSession),
-            cv.Optional(CONF_KEEP_ALIVE, default="10s"): cv.All(
-                cv.positive_time_period_milliseconds,
-                cv.Range(min=cv.TimePeriod(seconds=1), max=cv.TimePeriod(hours=1)),
-            ),
-            cv.Optional(CONF_TIMEOUT): cv.All(
-                cv.positive_time_period_milliseconds,
-                cv.Range(max=cv.TimePeriod(hours=3)),
-            ),
-            cv.Optional(CONF_BINARY_SENSOR): binary_sensor.binary_sensor_schema(
-                device_class=DEVICE_CLASS_CONNECTIVITY,
-                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            ),
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-    _session_timeout,
-)
-
-
-@SESSION.register(
-    "basic",
-    schema=BASIC_SESSION_SCHEMA,
-    single_peer=lambda config: True,
-    auto_load=lambda config: ["binary_sensor"] if CONF_BINARY_SENSOR in config else [],
-)
-async def build_basic_session(config: ConfigType, lower: MockObj) -> MockObj:
-    cg.add_define("USE_PACKET_INTERFACE_BASIC_SESSION")
-    var = cg.new_Pvariable(config[CONF_ID], lower)
-    cg.add(var.set_keep_alive(config[CONF_KEEP_ALIVE]))
-    cg.add(var.set_session_timeout(config[CONF_TIMEOUT]))
-    await cg.register_component(var, config)
-    binary_sensors = binary_sensor.sub_binary_sensors(config)
-    await binary_sensors(CONF_BINARY_SENSOR, var.set_connected_sensor)
-    return var

esphome/components/packet_interface/layers/hdlc_reliability.py

@@ -1,68 +0,0 @@
-"""Reliability layer using HDLC style acknowledgement and go-back-N retransmission."""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_TIMEOUT
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import RELIABILITY, PacketInterface, packet_interface_ns, remaining_packet_size
-
-CONF_ACK_DELAY = "ack_delay"
-CONF_MAX_QUEUE_LENGTH = "max_queue_length"
-CONF_MAX_RETRIES = "max_retries"
-
-# The control byte and the CRC-16
-FRAME_OVERHEAD = 3
-
-HdlcReliability = packet_interface_ns.class_("HdlcReliability", PacketInterface)
-
-
-def _ack_delay_within_timeout(config: ConfigType) -> ConfigType:
-    """The peer, configured the same, must hear the acknowledgement before its timeout."""
-    if (
-        config[CONF_ACK_DELAY].total_milliseconds
-        >= config[CONF_TIMEOUT].total_milliseconds
-    ):
-        raise cv.Invalid(
-            f"Must be shorter than '{CONF_TIMEOUT}'", path=[CONF_ACK_DELAY]
-        )
-    return config
-
-
-HDLC_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(HdlcReliability),
-            # Retransmitting more often than the main loop runs would exhaust the retries at once
-            cv.Optional(CONF_TIMEOUT, default="200ms"): cv.All(
-                cv.positive_time_period_milliseconds,
-                cv.Range(min=cv.TimePeriod(milliseconds=50)),
-            ),
-            cv.Optional(
-                CONF_ACK_DELAY, default="0ms"
-            ): cv.positive_time_period_milliseconds,
-            cv.Optional(CONF_MAX_QUEUE_LENGTH, default=4): cv.int_range(1, 7),
-            cv.Optional(CONF_MAX_RETRIES, default=5): cv.int_range(1, 255),
-        }
-    ).extend(cv.COMPONENT_SCHEMA),
-    _ack_delay_within_timeout,
-)
-
-
-@RELIABILITY.register(
-    "hdlc",
-    schema=HDLC_SCHEMA,
-    single_peer=lambda config: True,
-    packet_size=lambda config, size: remaining_packet_size(size, FRAME_OVERHEAD),
-    send_capacity=lambda config: config[CONF_MAX_QUEUE_LENGTH],
-)
-async def build_hdlc(config: ConfigType, lower: MockObj) -> MockObj:
-    cg.add_define("USE_PACKET_INTERFACE_HDLC")
-    var = cg.new_Pvariable(config[CONF_ID], lower)
-    cg.add(var.set_ack_timeout(config[CONF_TIMEOUT]))
-    cg.add(var.set_ack_delay(config[CONF_ACK_DELAY]))
-    cg.add(var.set_max_queue_length(config[CONF_MAX_QUEUE_LENGTH]))
-    cg.add(var.set_max_retries(config[CONF_MAX_RETRIES]))
-    await cg.register_component(var, config)
-    return var

esphome/components/packet_interface/layers/xxtea_encryption.py

@@ -1,61 +0,0 @@
-"""Encryption layer using XXTEA, with an optional rolling code."""
-
-import hashlib
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_KEY
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import ENCRYPTION, PacketInterface, packet_interface_ns, remaining_packet_size
-
-CONF_ROLLING_CODE_ENABLE = "rolling_code_enable"
-
-# A captured packet lets a guessed key be checked offline, so the key text is stretched to make each guess costly.
-# Both ends derive the same key from the same text, so the salt is fixed; it keeps tables built for other uses of
-# PBKDF2 from applying here.
-KEY_SALT = b"esphome packet_interface xxtea"
-KEY_ITERATIONS = 600_000
-
-# The check word, and with the rolling code the boot numbers and counter
-CHECK_SIZE = 4
-ROLLING_SIZE = 12
-
-XxteaEncryption = packet_interface_ns.class_("XxteaEncryption", PacketInterface)
-
-XXTEA_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(XxteaEncryption),
-        cv.Required(CONF_KEY): cv.All(cv.sensitive(cv.string), cv.Length(min=1)),
-        cv.Optional(CONF_ROLLING_CODE_ENABLE, default=False): cv.boolean,
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-def derive_key(text: str) -> list[int]:
-    """The 256-bit key for the key text, as 32-bit words in little endian order."""
-    digest = hashlib.pbkdf2_hmac("sha256", text.encode(), KEY_SALT, KEY_ITERATIONS)
-    return [int.from_bytes(digest[i : i + 4], "little") for i in range(0, 32, 4)]
-
-
-# The rolling code keeps the last counter of one peer, and accepts a packet only once the peer has sent back this
-# device's boot number
-@ENCRYPTION.register(
-    "xxtea",
-    schema=XXTEA_SCHEMA,
-    single_peer=lambda config: config[CONF_ROLLING_CODE_ENABLE],
-    needs_session=lambda config: config[CONF_ROLLING_CODE_ENABLE],
-    auto_load=lambda config: ["xxtea"],
-    # XXTEA works on whole 32-bit words
-    packet_size=lambda config, size: remaining_packet_size(
-        size & ~3,
-        CHECK_SIZE + (ROLLING_SIZE if config[CONF_ROLLING_CODE_ENABLE] else 0),
-    ),
-)
-async def build_xxtea(config: ConfigType, lower: MockObj) -> MockObj:
-    cg.add_define("USE_PACKET_INTERFACE_XXTEA")
-    var = cg.new_Pvariable(config[CONF_ID], lower, config[CONF_ROLLING_CODE_ENABLE])
-    cg.add(var.set_key(derive_key(config[CONF_KEY])))
-    await cg.register_component(var, config)
-    return var

esphome/components/packet_interface/listen_before_talk.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome::packet_interface {
-
-/**
- * Decides whether a half-duplex radio link may send while its radio reports that it is receiving a packet.
- *
- * Sending is refused while the radio is busy, so the packet being received is not lost. A busy period starts when a
- * send first finds the radio busy, and ends when a send finds it free or end_busy() is called. Once a busy period has
- * lasted max_busy_ms, sends go ahead, so a busy flag that never clears cannot stop sending for good, however often
- * sends are tried. Code generation sets max_busy_ms from the time the radio takes to receive the largest packet.
- */
-class ListenBeforeTalk {
- public:
-  static constexpr uint32_t DEFAULT_MAX_BUSY_MS = 2000;
-
-  void set_max_busy(uint32_t max_busy_ms) { this->max_busy_ms_ = max_busy_ms; }
-  uint32_t get_max_busy() const { return this->max_busy_ms_; }
-
-  /// True if a packet may be sent at \p now; \p busy says whether the radio is receiving.
-  bool may_send(bool busy, uint32_t now) {
-    if (!busy) {
-      this->busy_ = false;
-      return true;
-    }
-    if (!this->busy_) {
-      this->busy_ = true;
-      this->busy_since_ms_ = now;
-    }
-    return now - this->busy_since_ms_ >= this->max_busy_ms_;
-  }
-  /// Ends the busy period, when the radio is seen to be free other than by a send.
-  void end_busy() { this->busy_ = false; }
-  /// How long the current busy period has lasted at \p now.
-  uint32_t busy_for(uint32_t now) const { return now - this->busy_since_ms_; }
-
- protected:
-  uint32_t busy_since_ms_{0};
-  uint32_t max_busy_ms_{DEFAULT_MAX_BUSY_MS};
-  bool busy_{false};
-};
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/packet_buffer.h

@@ -1,173 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <span>
-#include <vector>
-
-namespace esphome::packet_interface {
-
-/**
- * A buffer class that efficiently represents a composite buffer with three sections:
- * - pre_buffer: A pointer to uint8_t data with a length
- * - mid_buffer: A reference to another PacketBuffer (optional)
- * - post_buffer: A pointer to uint8_t data with a length
- *
- * This allows efficient zero-copy composition of buffers without allocating new memory.
- *
- * WARNING: PacketBuffer holds raw pointers to data. The user must ensure that the data remains valid
- * for the lifetime of the PacketBuffer instance. Storing PacketBuffer instances beyond the scope of the data they
- * reference will lead to dangling pointers and undefined behavior, so to keep a packet, copy it with copy_to() into a
- * buffer allocated in setup().
- */
-class PacketBuffer {
- public:
-  PacketBuffer() = default;
-
-  // Disable copy semantics - PacketBuffer contains pointers and copying would create dangling references
-  PacketBuffer(const PacketBuffer &) = delete;
-  PacketBuffer &operator=(const PacketBuffer &) = delete;
-
-  // Enable move semantics
-  PacketBuffer(PacketBuffer &&) = default;
-  PacketBuffer &operator=(PacketBuffer &&) = default;
-
-  /**
-   * Construct from a single buffer.
-   */
-  PacketBuffer(const uint8_t *data, size_t length) : pre_buffer_(data), pre_length_(length) {}
-
-  /**
-   * Construct from a vector.
-   */
-  explicit PacketBuffer(const std::vector<uint8_t> &vec) : pre_buffer_(vec.data()), pre_length_(vec.size()) {}
-  // A temporary vector would leave the buffer dangling
-  explicit PacketBuffer(std::vector<uint8_t> &&) = delete;
-
-  /**
-   * Construct with pre and post buffers.
-   */
-  PacketBuffer(const uint8_t *pre_data, size_t pre_length, const uint8_t *post_data, size_t post_length)
-      : pre_buffer_(pre_data), pre_length_(pre_length), post_buffer_(post_data), post_length_(post_length) {}
-
-  /**
-   * Construct with pre, mid, and post buffers.
-   */
-  PacketBuffer(const uint8_t *pre_data, size_t pre_length, const PacketBuffer *mid_buffer, const uint8_t *post_data,
-               size_t post_length)
-      : pre_buffer_(pre_data),
-        pre_length_(pre_length),
-        mid_buffer_(mid_buffer),
-        post_buffer_(post_data),
-        post_length_(post_length) {}
-
-  /**
-   * Get the total size of the buffer.
-   */
-  size_t size() const {
-    size_t total = this->pre_length_ + this->post_length_;
-    if (this->mid_buffer_ != nullptr) {
-      total += this->mid_buffer_->size();
-    }
-    return total;
-  }
-
-  /**
-   * Check if the buffer is empty.
-   */
-  bool empty() const { return this->size() == 0; }
-
-  /**
-   * Check if all the data is held in the pre-buffer, so it can be read as one span.
-   */
-  bool is_contiguous() const { return this->mid_buffer_ == nullptr && this->post_length_ == 0; }
-
-  /**
-   * Get the data as one span. Only valid when is_contiguous() is true.
-   */
-  std::span<const uint8_t> as_span() const { return {this->pre_buffer_, this->pre_length_}; }
-
-  /**
-   * Access a byte at a specific position.
-   * @param index The position to access
-   * @return The byte at the specified position, or 0 past the end
-   */
-  uint8_t operator[](size_t index) const {
-    if (index < this->pre_length_) {
-      return this->pre_buffer_[index];
-    }
-    index -= this->pre_length_;
-
-    if (this->mid_buffer_ != nullptr) {
-      size_t mid_size = this->mid_buffer_->size();
-      if (index < mid_size) {
-        return (*this->mid_buffer_)[index];
-      }
-      index -= mid_size;
-    }
-
-    return index < this->post_length_ ? this->post_buffer_[index] : 0;
-  }
-
-  /**
-   * Copy data from the buffer to a destination pointer.
-   * @param dest Destination pointer
-   * @param count Number of bytes to copy
-   * @param offset Offset in the source buffer to start copying from
-   * @return Number of bytes actually copied
-   */
-  size_t copy_to(uint8_t *dest, size_t count, size_t offset = 0) const {
-    size_t total_size = this->size();
-    if (offset >= total_size) {
-      return 0;
-    }
-
-    size_t available = total_size - offset;
-    size_t to_copy = count < available ? count : available;
-    size_t copied = 0;
-
-    // Copy from pre_buffer
-    if (offset < this->pre_length_) {
-      size_t pre_offset = offset;
-      size_t pre_available = this->pre_length_ - pre_offset;
-      size_t pre_copy = to_copy < pre_available ? to_copy : pre_available;
-      std::memcpy(dest, this->pre_buffer_ + pre_offset, pre_copy);
-      copied += pre_copy;
-      dest += pre_copy;
-      offset += pre_copy;
-    }
-
-    // Copy from mid_buffer
-    size_t mid_size = this->mid_buffer_ != nullptr ? this->mid_buffer_->size() : 0;
-    if (copied < to_copy && offset < this->pre_length_ + mid_size) {
-      size_t mid_offset = offset - this->pre_length_;
-      size_t mid_available = mid_size - mid_offset;
-      size_t mid_copy = (to_copy - copied) < mid_available ? (to_copy - copied) : mid_available;
-      this->mid_buffer_->copy_to(dest, mid_copy, mid_offset);
-      copied += mid_copy;
-      dest += mid_copy;
-      offset += mid_copy;
-    }
-
-    // Copy from post_buffer
-    if ((copied < to_copy) && (this->post_length_ > 0)) {
-      size_t post_offset = offset - this->pre_length_ - mid_size;
-      size_t post_available = this->post_length_ - post_offset;
-      size_t post_copy = (to_copy - copied) < post_available ? (to_copy - copied) : post_available;
-      std::memcpy(dest, this->post_buffer_ + post_offset, post_copy);
-      copied += post_copy;
-    }
-
-    return copied;
-  }
-
- private:
-  const uint8_t *pre_buffer_{nullptr};
-  size_t pre_length_{0};
-  const PacketBuffer *mid_buffer_{nullptr};
-  const uint8_t *post_buffer_{nullptr};
-  size_t post_length_{0};
-};
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/packet_interface.cpp

@@ -1,39 +0,0 @@
-#include "packet_interface.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface");
-
-// Packets in a row that cannot be understood before the mismatch is logged
-static constexpr uint8_t MISMATCH_COUNT = 10;
-
-void PacketInterface::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Packet Interface '%s':\n"
-                "  Max Packet Size: %zu",
-                this->name_, this->get_max_packet_size());
-}
-
-void PacketInterface::on_receive_from_interface_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-#ifdef ESPHOME_LOG_HAS_VERBOSE
-  static constexpr size_t LOG_BYTES = 24;
-  uint8_t head[LOG_BYTES];
-  size_t len = data.copy_to(head, LOG_BYTES);
-  ESP_LOGV_HEX(TAG, head, len, LOG_BYTES, "%s: received %zu bytes %s", this->name_, data.size());
-#endif
-  this->callback_.call(data, meta_data);
-}
-
-void PacketInterface::note_received_(bool understood) {
-  if (understood) {
-    this->not_understood_count_ = 0;
-  } else if (this->not_understood_count_ < MISMATCH_COUNT) {
-    this->not_understood_count_++;
-    if (this->not_understood_count_ == MISMATCH_COUNT) {
-      ESP_LOGW(TAG, "%s: %u packets in a row could not be understood; check that both ends have the same layers",
-               this->name_, MISMATCH_COUNT);
-    }
-  }
-}
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/packet_interface.h

@@ -1,149 +0,0 @@
-#pragma once
-
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <utility>
-
-#include "esphome/core/string_ref.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/component.h"
-#include "packet_buffer.h"
-
-namespace esphome::packet_interface {
-
-/// The room left for a packet of \p size bytes after \p used bytes, or 0 if it is too small.
-constexpr size_t remaining_packet_size(size_t size, size_t used) { return size > used ? size - used : 0; }
-
-/// What a stack of layers provides, as bits of PacketInterface::get_capabilities().
-enum Capability : uint8_t {
-  CAPABILITY_ENCRYPTION = 1 << 0,
-  CAPABILITY_RELIABILITY = 1 << 1,
-  CAPABILITY_SESSION = 1 << 2,
-  CAPABILITY_ADDRESSING = 1 << 3,
-  CAPABILITY_FRAGMENTATION = 1 << 4,
-};
-
-/**
- * A struct to hold metadata about a packet.
- * @param info Additional information about the packet
- * @param source_address With an addressing layer, the sender of a received packet; 0 if not known
- * @param destination_address With an addressing layer, the destination of a packet; when sending, 0 uses the
- * configured destination
- * @param rssi The RSSI of the packet
- * @param snr The SNR of the packet
- * @param mac_address The MAC address of the sender/receiver
- */
-class PacketMetaData {
- public:
-  StringRef info{};
-  uint16_t source_address{0};
-  uint16_t destination_address{0};
-  float rssi{NAN};
-  float snr{NAN};
-  uint8_t mac_address[MAC_ADDRESS_SIZE]{};
-};
-/**
- * A class that will transport data to and from an abstract channel.
- *
- * The operations defined are:
- *
- * Transmit: the function send_to_interface() takes a PacketBuffer of bytes, and returns when all data is
- * written or buffered for transmission.
- *
- * Receive: The callbacks for an instance of this class are called with currently received data.
- */
-class PacketInterface : public Component {
- public:
-  /**
-   *
-   * Method to be implemented by child classes to send data to the interface.
-   *
-   * @param data The data to be sent
-   * @param meta_data Metadata about the packet to be sent
-   * @return True if the data was queued for transmission, false if it could not be sent
-   */
-  virtual bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) = 0;
-
-  /// The largest packet this layer accepts; fixed when the layer is constructed.
-  size_t get_max_packet_size() const { return this->max_packet_size_; }
-  /// How many packets send_to_interface() would accept now, so a layer above can tell before sending a series.
-  virtual size_t get_send_capacity() const { return SIZE_MAX; }
-  /// The capabilities of this layer and every layer below it.
-  uint8_t get_capabilities() const { return this->capabilities_; }
-  bool has_capability(Capability capability) const { return (this->capabilities_ & capability) != 0; }
-  /**
-   * With CAPABILITY_SESSION, the callback is called with true when the peer can be reached, including after it
-   * restarts, and with false when it is lost. The session layer is always the top layer, so register on top().
-   * A reliability layer calls it with false when it resets the link and discards data, which the session layer above
-   * reports as the session lost.
-   */
-  template<typename F> void add_on_session_state_callback(F &&callback) {
-    this->session_callback_.add(std::forward<F>(callback));
-  }
-
-  /// The topmost layer stacked on this one, or this one if nothing is stacked on it.
-  PacketInterface *top() {
-    PacketInterface *layer = this;
-    while (layer->upper_ != nullptr)
-      layer = layer->upper_;
-    return layer;
-  }
-  /// Name shown in log messages; a layer takes the name of the link it is stacked on.
-  void set_name(const char *name) { this->name_ = name; }
-  const char *get_name() const { return this->name_; }
-
-  /**
-   * Add a listener that will be called when data is received.
-   *
-   * @param callback The callback to be called when data is received.
-   */
-  template<typename F> void add_packet_interface_listener(F &&callback) {
-    this->callback_.add(std::forward<F>(callback));
-  }
-
-  void dump_config() override;
-
- protected:
-  /// @param max_packet_size The largest packet the layer accepts, set from the layer below or the layer's own buffer
-  explicit PacketInterface(size_t max_packet_size) : max_packet_size_(max_packet_size) {}
-
-  virtual ~PacketInterface() = default;
-  /**
-   * This function should be called by implementing classes with received data to be passed to any listeners.
-   *
-   * @param data The received data
-   * @param meta_data Metadata about the received packet
-   */
-  void on_receive_from_interface_(const PacketBuffer &data, const PacketMetaData &meta_data);
-  /**
-   * Called by a layer for each received packet it understood, or could not make sense of. A run of packets that
-   * cannot be understood usually means the peer has different layers configured, which is logged once per run.
-   */
-  void note_received_(bool understood);
-  /// Called by a layer's constructor to record itself as the layer above \p lower, adding its own capability.
-  void stack_on_(PacketInterface *lower, Capability capability) {
-    lower->upper_ = this;
-    this->inherit_from_(lower, capability);
-  }
-  /// Takes the name and capabilities of `lower` without becoming its top, for one of several stacks on a link.
-  void inherit_from_(PacketInterface *lower, Capability capability) {
-    this->name_ = lower->name_;
-    this->capabilities_ = lower->capabilities_ | capability;
-    // A link that has a session of its own, such as TCP, reports it to whatever is stacked above, as does a
-    // reliability layer that discards data; the session layer handles the latter itself
-    if ((lower->has_capability(CAPABILITY_SESSION) || lower->has_capability(CAPABILITY_RELIABILITY)) &&
-        capability != CAPABILITY_SESSION) {
-      lower->add_on_session_state_callback([this](bool connected) { this->session_callback_.call(connected); });
-    }
-  }
-
-  LazyCallbackManager<void(const PacketBuffer &, const PacketMetaData &)> callback_;
-  LazyCallbackManager<void(bool)> session_callback_;
-  PacketInterface *upper_{nullptr};
-  const char *name_{""};
-  const size_t max_packet_size_;
-  uint8_t capabilities_{0};
-  uint8_t not_understood_count_{0};
-};
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/packet_transport/__init__.py

@@ -1,35 +0,0 @@
-import esphome.codegen as cg
-from esphome.components.packet_transport import (
-    PacketTransport,
-    new_packet_transport,
-    transport_schema,
-)
-import esphome.config_validation as cv
-from esphome.types import ConfigType
-
-from .. import (
-    CONF_PACKET_INTERFACE,
-    PacketInterface,
-    final_validate_interface,
-    packet_interface_ns,
-)
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["packet_interface"]
-
-PacketInterfaceTransport = packet_interface_ns.class_(
-    "PacketInterfaceTransport", PacketTransport
-)
-
-CONFIG_SCHEMA = transport_schema(PacketInterfaceTransport).extend(
-    {
-        cv.GenerateID(CONF_PACKET_INTERFACE): cv.use_id(PacketInterface),
-    }
-)
-
-FINAL_VALIDATE_SCHEMA = final_validate_interface(CONF_PACKET_INTERFACE)
-
-
-async def to_code(config: ConfigType) -> None:
-    interface = await cg.get_variable(config[CONF_PACKET_INTERFACE])
-    await new_packet_transport(config, interface)

esphome/components/packet_interface/packet_transport/packet_interface_transport.cpp

@@ -1,29 +0,0 @@
-#include "packet_interface_transport.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.transport");
-
-void PacketInterfaceTransport::setup() {
-  PacketTransport::setup();
-  this->interface_ = this->interface_->top();
-  this->interface_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &) { this->receive_(data); });
-}
-
-void PacketInterfaceTransport::receive_(const PacketBuffer &data) {
-  // Packet interface layers deliver packets in one piece
-  if (!data.is_contiguous()) {
-    ESP_LOGW(TAG, "Packet split across buffers is not supported");
-    return;
-  }
-  this->process_(data.as_span());
-}
-
-void PacketInterfaceTransport::send_packet(const std::vector<uint8_t> &buf) const {
-  if (!this->interface_->send_to_interface(PacketBuffer(buf), {}))
-    ESP_LOGD(TAG, "Failed to send packet of %zu bytes", buf.size());
-}
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/packet_transport/packet_interface_transport.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "esphome/components/packet_interface/packet_interface.h"
-#include "esphome/components/packet_transport/packet_transport.h"
-
-namespace esphome::packet_interface {
-
-/**
- * A transport protocol adapter that bridges PacketInterface to PacketTransport.
- * This allows packet_transport functionality to be used with any PacketInterface implementation.
- */
-class PacketInterfaceTransport : public packet_transport::PacketTransport {
- public:
-  explicit PacketInterfaceTransport(PacketInterface *interface) : interface_(interface) {}
-
-  void setup() override;
-
-  float get_setup_priority() const override { return setup_priority::PROCESSOR; }
-
- protected:
-  // implementing PacketTransport virtual methods
-  size_t get_max_packet_size() override { return this->interface_->top()->get_max_packet_size(); }
-  void send_packet(const std::vector<uint8_t> &buf) const override;
-  void receive_(const PacketBuffer &data);
-
-  PacketInterface *interface_;
-};
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/radio_link.cpp

@@ -1,54 +0,0 @@
-#include "radio_link.h"
-#include <cinttypes>
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.radio");
-
-bool RadioLinkBase::check_size_(size_t size) const {
-  if (size <= this->max_packet_size_)
-    return true;
-  ESP_LOGW(TAG, "Packet of %zu bytes is larger than %zu", size, this->max_packet_size_);
-  return false;
-}
-
-bool RadioLinkBase::may_send_(bool busy) {
-  uint32_t now = App.get_loop_component_start_time();
-  if (busy)
-    this->enable_loop();
-  if (!this->listen_before_talk_.may_send(busy, now))
-    return false;
-  if (busy) {
-    // The limit is longer than any packet takes, so the radio's busy indication is stuck or the channel is jammed
-    ESP_LOGW(TAG, "Radio busy for %" PRIu32 "ms, sending anyway", this->listen_before_talk_.busy_for(now));
-  }
-  return true;
-}
-
-bool RadioLinkBase::skip_empty_() const {
-  ESP_LOGV(TAG, "Empty packet not sent");
-  return true;
-}
-
-void RadioLinkBase::radio_not_ready_(bool failed) {
-  if (!failed || this->failed_warned_)
-    return;
-  this->failed_warned_ = true;
-  ESP_LOGW(TAG, "%s: The radio failed to set up, so nothing can be sent", this->name_);
-}
-
-void RadioLinkBase::radio_free_() {
-  this->listen_before_talk_.end_busy();
-  this->disable_loop();
-}
-
-void RadioLinkBase::receive_(const std::vector<uint8_t> &packet, float rssi, float snr) {
-  PacketMetaData meta_data;
-  meta_data.rssi = rssi;
-  meta_data.snr = snr;
-  this->on_receive_from_interface_(PacketBuffer(packet.data(), packet.size()), meta_data);
-}
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/radio_link.h

@@ -1,87 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include "esphome/components/packet_interface/listen_before_talk.h"
-#include "esphome/components/packet_interface/packet_interface.h"
-
-namespace esphome::packet_interface {
-
-/// The parts of RadioLink that do not depend on the radio.
-class RadioLinkBase : public PacketInterface {
- public:
-  void set_max_busy(uint32_t max_busy_ms) { this->listen_before_talk_.set_max_busy(max_busy_ms); }
-
- protected:
-  explicit RadioLinkBase(size_t max_packet_size) : PacketInterface(max_packet_size) {}
-  /// False if a packet of this size is too large.
-  bool check_size_(size_t size) const;
-  /// False if sending must wait, as the radio is busy; starts loop() to watch the radio.
-  bool may_send_(bool busy);
-  /// Returns true for an empty packet, which the radios cannot send, so there is nothing to retry.
-  bool skip_empty_() const;
-  /// Warns once when a send finds the radio failed; until its setup has run, sends are refused quietly.
-  void radio_not_ready_(bool failed);
-  /// Ends the busy period when loop() finds the radio free.
-  void radio_free_();
-  void receive_(const std::vector<uint8_t> &packet, float rssi, float snr);
-
-  ListenBeforeTalk listen_before_talk_;
-  bool failed_warned_{false};
-};
-
-/**
- * A packet interface link over a packet radio: each packet is one radio packet, with the RSSI and SNR of received
- * packets in the metadata. Sending waits for the radio to finish transmitting. A radio cannot hear while it sends, so
- * sending is refused while the radio is receiving a packet. A reliability layer sends the packet again shortly, and
- * entity_transport after a delay; other callers drop it, logging at debug level at most. While a busy period lasts,
- * loop() watches the radio and ends the period as soon as the radio is free, so a later reception starts a new one.
- *
- * Radio provides is_receiving(), register_listener(Listener *) and transmit_packet(const uint8_t *, size_t), which
- * returns Error::NONE on success. Listener declares on_packet(packet, rssi, snr). MaxPacketSize is the radio's limit.
- */
-template<typename Radio, typename Listener, typename Error, size_t MaxPacketSize>
-class RadioLink : public RadioLinkBase, public Listener {
- public:
-  RadioLink(Radio *radio, size_t max_packet_size) : RadioLinkBase(max_packet_size), radio_(radio) {}
-
-  void setup() override {
-    this->radio_->register_listener(this);
-    this->disable_loop();
-  }
-  // Runs only during a busy period; a busy flag that never clears keeps it running. A radio that failed meanwhile
-  // is not read again, as reading it may wait on the radio every time
-  void loop() override {
-    if (!this->radio_->is_ready() || !this->radio_->is_receiving())
-      this->radio_free_();
-  }
-
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override {
-    // The radio is set up after the layers above, which may send from their own setup
-    if (!this->radio_->is_ready()) {
-      this->radio_not_ready_(this->radio_->is_failed());
-      return false;
-    }
-    size_t size = data.size();
-    if (size == 0)
-      return this->skip_empty_();
-    if (!this->check_size_(size) || !this->may_send_(this->radio_->is_receiving()))
-      return false;
-    if (data.is_contiguous()) {
-      auto span = data.as_span();
-      return this->radio_->transmit_packet(span.data(), span.size()) == Error::NONE;
-    }
-    uint8_t buf[MaxPacketSize];
-    data.copy_to(buf, size);
-    return this->radio_->transmit_packet(buf, size) == Error::NONE;
-  }
-
-  void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) override {
-    this->receive_(packet, rssi, snr);
-  }
-
- protected:
-  Radio *radio_;
-};
-
-}  // namespace esphome::packet_interface

esphome/components/packet_interface/radio_link.py

@@ -1,138 +0,0 @@
-"""Shared code generation for the packet interface links over packet radios, such as the SX126x and SX127x."""
-
-from collections.abc import Callable
-import math
-
-import esphome.codegen as cg
-from esphome.components.const import CONF_MAX_PACKET_SIZE
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.core import CORE, EsphomeError
-from esphome.cpp_generator import MockObjClass
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from . import new_packet_interface, packet_interface_schema
-from .layers import CONF_ADDRESSING, CONF_PEERS, STACK_ORDER
-
-# The radios' payload length register is 8 bits
-MAX_PACKET_SIZE = 255
-
-# Listen before talk holds a send back for at most the airtime of the largest packet, and never less than this
-MIN_MAX_BUSY_MS = 2000
-# Room for the preamble detection and the radio's own delays
-MARGIN = 1.25
-
-
-def packet_airtime_ms(radio: ConfigType, size: int) -> float:
-    """The time a radio configured as in radio takes to send a packet of size bytes.
-
-    LoRa follows the Semtech formula for an explicit header; the low data rate optimization is assumed when a symbol
-    takes more than 16 ms, as the drivers enable it. Other modulations count the preamble, sync word, length byte,
-    payload and CRC at the bitrate, treating the preamble size as bytes, which gives the longer time.
-    """
-    if str(radio["modulation"]) == "LORA":
-        spreading_factor = radio["spreading_factor"]
-        bandwidth_hz = (
-            float(str(radio["bandwidth"]).removesuffix("kHz").replace("_", ".")) * 1000
-        )
-        coding_rate = int(str(radio["coding_rate"])[-1]) - 4
-        symbol_s = (1 << spreading_factor) / bandwidth_hz
-        low_data_rate = 1 if symbol_s > 0.016 else 0
-        crc = 16 if radio.get("crc_enable", False) else 0
-        payload_symbols = 8 + max(
-            math.ceil(
-                (8 * size - 4 * spreading_factor + 28 + crc)
-                / (4 * (spreading_factor - 2 * low_data_rate))
-            )
-            * (coding_rate + 4),
-            0,
-        )
-        return (radio["preamble_size"] + 4.25 + payload_symbols) * symbol_s * 1000
-    bytes_sent = (
-        radio["preamble_size"] + len(radio.get("sync_value", [])) + 1 + size + 2
-    )
-    return bytes_sent * 8 / radio["bitrate"] * 1000
-
-
-def max_busy_ms(radio: ConfigType, max_packet_size: int) -> int:
-    """How long listen before talk may hold a send back."""
-    return max(
-        MIN_MAX_BUSY_MS, math.ceil(packet_airtime_ms(radio, max_packet_size) * MARGIN)
-    )
-
-
-def radio_link_schema(
-    class_: MockObjClass, radio_id_key: str, radio_class: MockObjClass
-) -> cv.Schema:
-    """Schema for a radio link, referring to its radio by radio_id_key."""
-    return packet_interface_schema(class_, MAX_PACKET_SIZE, MAX_PACKET_SIZE).extend(
-        {cv.GenerateID(radio_id_key): cv.use_id(radio_class)}
-    )
-
-
-def _radio_config(config: ConfigType, radio_id_key: str) -> ConfigType:
-    full_config = fv.full_config.get()
-    return full_config.get_config_for_path(
-        full_config.get_path_for_id(config[radio_id_key])[:-1]
-    )
-
-
-def _two_way_layer(config: ConfigType) -> str | None:
-    """The first layer on the link or in a peer that keeps state for one peer, so needs packets back from it."""
-    for stack in (config, *config.get(CONF_ADDRESSING, {}).get(CONF_PEERS, [])):
-        for kind in STACK_ORDER:
-            if (layer := stack.get(kind.key)) is not None and kind.get_type(
-                layer
-            ).single_peer(layer):
-                return kind.key
-    return None
-
-
-def radio_link_final_validate(
-    radio_id_key: str,
-    payload_length_key: str,
-    rx_start_key: str,
-    check: Callable[[ConfigType, ConfigType], None] | None = None,
-) -> Callable[[ConfigType], ConfigType]:
-    """Final validation for a radio link: packets vary in length, the radio listens after sending when a layer needs
-    replies, and check(link, radio) checks the rest.
-    """
-
-    def validator(config: ConfigType) -> ConfigType:
-        radio = _radio_config(config, radio_id_key)
-        if radio[payload_length_key] != 0:
-            raise cv.Invalid(
-                f"Packets vary in length, so the radio's '{payload_length_key}' must be 0",
-                path=[radio_id_key],
-            )
-        if not radio[rx_start_key] and (layer := _two_way_layer(config)) is not None:
-            raise cv.Invalid(
-                f"This '{layer}' needs packets from the peer, but the radio sleeps after sending unless "
-                f"'{rx_start_key}' is true",
-                path=[radio_id_key],
-            )
-        if check is not None:
-            check(config, radio)
-        return config
-
-    return validator
-
-
-async def new_radio_link(
-    config: ConfigType, radio_id_key: str, radio_domain: str
-) -> None:
-    """Create a radio link, with its listen before talk limit worked out from the radio's settings."""
-    radio = await cg.get_variable(config[radio_id_key])
-    var = await new_packet_interface(config, radio, config[CONF_MAX_PACKET_SIZE])
-    radio_config = next(
-        (
-            conf
-            for conf in CORE.config[radio_domain]
-            if conf[CONF_ID] == config[radio_id_key]
-        ),
-        None,
-    )
-    if radio_config is None:
-        raise EsphomeError(f"No {radio_domain} radio with id '{config[radio_id_key]}'")
-    cg.add(var.set_max_busy(max_busy_ms(radio_config, config[CONF_MAX_PACKET_SIZE])))

esphome/components/packet_interface/xxtea_encryption.cpp

@@ -1,182 +0,0 @@
-#include "xxtea_encryption.h"
-#ifdef USE_PACKET_INTERFACE_XXTEA
-#include <algorithm>
-#include <cstring>
-#include "esphome/components/xxtea/xxtea.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::packet_interface {
-
-ESPHOME_LOG_TAG(TAG, "packet_interface.xxtea");
-
-static constexpr uint32_t PREF_HASH = fnv1a_hash("packet_interface.xxtea");
-// Different for each mode, so devices set up differently drop each other's packets
-static constexpr uint8_t CHECK_BYTES[3] = {0x58, 0x54, 0x45};
-static constexpr uint8_t ROLLING_CHECK_BYTES[3] = {0x58, 0x54, 0x52};
-static constexpr size_t CHECK_SIZE = 4;
-// Boot number, counter, and the echo of the receiver's boot number
-static constexpr size_t ROLLING_SIZE = 12;
-// XXTEA needs at least two words
-static constexpr size_t MIN_LENGTH = 8;
-static constexpr size_t MAX_PADDING = 4;
-
-static void put_uint32(uint8_t *buf, uint32_t value) {
-  buf[0] = value;
-  buf[1] = value >> 8;
-  buf[2] = value >> 16;
-  buf[3] = value >> 24;
-}
-
-static uint32_t get_uint32(const uint8_t *buf) { return encode_uint32(buf[3], buf[2], buf[1], buf[0]); }
-
-static constexpr size_t trailer_size(bool rolling_code) {
-  return rolling_code ? ROLLING_SIZE + CHECK_SIZE : CHECK_SIZE;
-}
-
-XxteaEncryption::XxteaEncryption(PacketInterface *lower, bool rolling_code)
-    // XXTEA works on whole 32-bit words
-    : PacketInterface(remaining_packet_size(lower->get_max_packet_size() & ~size_t{3}, trailer_size(rolling_code))),
-      lower_(lower),
-      trailer_size_(trailer_size(rolling_code)),
-      rolling_code_(rolling_code) {
-  this->stack_on_(lower, CAPABILITY_ENCRYPTION);
-}
-
-void XxteaEncryption::set_key(std::initializer_list<uint32_t> key) {
-  std::copy_n(key.begin(), std::min(key.size(), this->key_.size()), this->key_.begin());
-}
-
-void XxteaEncryption::setup() {
-  if (this->max_packet_size_ == 0) {
-    this->mark_failed(LOG_STR("max_packet_size too small for the configured layers"));
-    return;
-  }
-  size_t words = this->lower_->get_max_packet_size() / 4;
-  RAMAllocator<uint32_t> allocator;
-  this->tx_buffer_ = allocator.allocate(words * 2);
-  if (this->tx_buffer_ == nullptr) {
-    this->mark_failed(LOG_STR("Not enough memory for the packet buffers"));
-    return;
-  }
-  this->rx_buffer_ = this->tx_buffer_ + words;
-  if (this->rolling_code_) {
-    this->pref_ = global_preferences->make_preference<uint32_t>(fnv1a_hash_extend(PREF_HASH, this->name_), true);
-    this->pref_.load(&this->boot_);
-    this->next_boot_();
-  }
-  this->lower_->add_packet_interface_listener(
-      [this](const PacketBuffer &data, const PacketMetaData &meta_data) { this->receive_(data, meta_data); });
-}
-
-void XxteaEncryption::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "XXTEA Encryption on '%s':\n"
-                "  Max Packet Size: %zu\n"
-                "  Rolling Code: %s",
-                this->name_, this->max_packet_size_, YESNO(this->rolling_code_));
-  if (this->rolling_code_) {
-    ESP_LOGCONFIG(TAG, "  Boot Number: %" PRIu32, this->boot_);
-  }
-}
-
-// A new boot number must be saved before it is used, or a crash could make the peer see it again
-void XxteaEncryption::next_boot_() {
-  this->boot_++;
-  this->counter_ = 0;
-  if (!this->pref_.save(&this->boot_) || !global_preferences->sync()) {
-    ESP_LOGW(TAG, "%s: Could not save the boot number, so a restart could reuse it", this->name_);
-  }
-}
-
-bool XxteaEncryption::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  if (this->tx_buffer_ == nullptr)
-    return false;
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  size_t padding = (4 - (size + this->trailer_size_) % 4) % 4;
-  if (size + padding + this->trailer_size_ < MIN_LENGTH)
-    padding += 4;
-  size_t length = size + padding + this->trailer_size_;
-  auto *buf = reinterpret_cast<uint8_t *>(this->tx_buffer_);
-  data.copy_to(buf, size);
-  memset(buf + size, 0, padding);
-  uint8_t *check = buf + length - CHECK_SIZE;
-  if (this->rolling_code_) {
-    put_uint32(check - ROLLING_SIZE, this->boot_);
-    put_uint32(check - ROLLING_SIZE + 4, this->counter_);
-    put_uint32(check - ROLLING_SIZE + 8, this->echo_boot_);
-    memcpy(check, ROLLING_CHECK_BYTES, sizeof(ROLLING_CHECK_BYTES));
-    if (++this->counter_ == 0)
-      this->next_boot_();
-  } else {
-    memcpy(check, CHECK_BYTES, sizeof(CHECK_BYTES));
-  }
-  check[CHECK_SIZE - 1] = padding;
-  xxtea::encrypt(this->tx_buffer_, length / 4, this->key_.data());
-  return this->lower_->send_to_interface(PacketBuffer(buf, length), meta_data);
-}
-
-bool XxteaEncryption::accept_counter_(uint32_t boot, uint32_t counter) {
-  if (this->peer_seen_ && (boot < this->peer_boot_ || (boot == this->peer_boot_ && counter <= this->peer_counter_)))
-    return false;
-  this->peer_seen_ = true;
-  this->peer_boot_ = boot;
-  this->peer_counter_ = counter;
-  return true;
-}
-
-void XxteaEncryption::receive_(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  size_t length = data.size();
-  if (length % 4 != 0 || length < std::max(MIN_LENGTH, this->trailer_size_) ||
-      length > this->lower_->get_max_packet_size()) {
-    ESP_LOGV(TAG, "%s: Packet of %zu bytes dropped", this->name_, length);
-    this->note_received_(false);
-    return;
-  }
-  auto *buf = reinterpret_cast<uint8_t *>(this->rx_buffer_);
-  data.copy_to(buf, length);
-  xxtea::decrypt(this->rx_buffer_, length / 4, this->key_.data());
-  const uint8_t *check = buf + length - CHECK_SIZE;
-  const uint8_t *expected = this->rolling_code_ ? ROLLING_CHECK_BYTES : CHECK_BYTES;
-  size_t padding = check[CHECK_SIZE - 1];
-  if (memcmp(check, expected, sizeof(CHECK_BYTES)) != 0 || padding > MAX_PADDING ||
-      padding > length - this->trailer_size_) {
-    ESP_LOGV(TAG, "%s: Packet failed authentication", this->name_);
-    this->note_received_(false);
-    return;
-  }
-  this->note_received_(true);
-  if (this->rolling_code_) {
-    uint32_t boot = get_uint32(check - ROLLING_SIZE);
-    uint32_t counter = get_uint32(check - ROLLING_SIZE + 4);
-    uint32_t echo = get_uint32(check - ROLLING_SIZE + 8);
-    // Learn the peer's boot number even from a packet that is then dropped, so both sides can catch up
-    if (boot > this->echo_boot_)
-      this->echo_boot_ = boot;
-    // A packet recorded before this boot cannot carry this boot's number
-    if (echo != this->boot_) {
-      ESP_LOGV(TAG, "%s: Packet for boot %" PRIu32 " dropped", this->name_, echo);
-      return;
-    }
-    if (!this->accept_counter_(boot, counter)) {
-      // A boot number lower than one already heard means the peer lost its saved boot number, or a replay
-      if (boot < this->peer_boot_ && !this->old_boot_warned_) {
-        this->old_boot_warned_ = true;
-        ESP_LOGW(TAG,
-                 "%s: Packets from an older boot %" PRIu32 " of the peer are dropped; if its flash was erased, "
-                 "restart this device",
-                 this->name_, boot);
-      }
-      ESP_LOGV(TAG, "%s: Old packet %" PRIu32 ":%" PRIu32 " dropped", this->name_, boot, counter);
-      return;
-    }
-  }
-  this->on_receive_from_interface_(PacketBuffer(buf, length - this->trailer_size_ - padding), meta_data);
-}
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_interface/xxtea_encryption.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_PACKET_INTERFACE_XXTEA
-#include <array>
-#include <initializer_list>
-
-#include "esphome/core/preferences.h"
-#include "packet_interface.h"
-
-namespace esphome::packet_interface {
-
-/**
- * An encryption layer that encrypts and authenticates each packet with XXTEA and a 256-bit shared key.
- *
- * The packet is padded with zeros and followed by a trailer, then the whole is encrypted as one block. With the
- * rolling code enabled, the trailer starts with:
- * - a 32-bit boot number, saved in flash and increased at every boot;
- * - a 32-bit packet counter, starting at 0 at every boot;
- * - the highest boot number heard from the peer, echoed back to it.
- * The trailer always ends with 3 fixed check bytes and the number of padding bytes. XXTEA mixes the whole block, so
- * a packet that was changed or encrypted with another key fails the check.
- * With the rolling code, a packet is dropped as a replay unless it echoes this device's current boot number, and its
- * boot number and counter are higher than those of the last packet accepted from the peer. A boot number is never
- * reused, so the echo acts as a fresh challenge after every restart.
- */
-class XxteaEncryption : public PacketInterface {
- public:
-  XxteaEncryption(PacketInterface *lower, bool rolling_code);
-
-  void setup() override;
-  void dump_config() override;
-  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
-
-  void set_key(std::initializer_list<uint32_t> key);
-
- protected:
-  void receive_(const PacketBuffer &data, const PacketMetaData &meta_data);
-  bool accept_counter_(uint32_t boot, uint32_t counter);
-  void next_boot_();
-
-  PacketInterface *lower_;
-  const size_t trailer_size_;
-  std::array<uint32_t, 8> key_{};
-  // Separate buffers, as a layer above may send a reply while a received packet is being passed up; both are in one
-  // block allocated in setup(), and tx_buffer_ stays null if that fails
-  uint32_t *tx_buffer_{nullptr};
-  uint32_t *rx_buffer_{nullptr};
-  ESPPreferenceObject pref_;
-  uint32_t boot_{0};
-  uint32_t counter_{0};
-  uint32_t peer_boot_{0};
-  uint32_t peer_counter_{0};
-  uint32_t echo_boot_{0};  // highest boot number heard from the peer
-  bool peer_seen_{false};
-  bool old_boot_warned_{false};
-  const bool rolling_code_;
-};
-
-}  // namespace esphome::packet_interface
-#endif

esphome/components/packet_transport/__init__.py

@@ -205,10 +205,8 @@ async def register_packet_transport(var: MockObj, config: ConfigType) -> set[str
     return providers
 
 
-async def new_packet_transport(
-    config: ConfigType, *args: Any
-) -> tuple[MockObj, set[str]]:
-    var = cg.new_Pvariable(config[CONF_ID], *args)
+async def new_packet_transport(config: ConfigType) -> tuple[MockObj, set[str]]:
+    var = cg.new_Pvariable(config[CONF_ID])
     cg.add(var.set_platform_name(config[CONF_PLATFORM]))
     providers = await register_packet_transport(var, config)
     return var, providers

esphome/components/packet_transport/packet_transport.cpp

@@ -547,11 +547,9 @@ void PacketTransport::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Packet Transport:\n"
                 "  Platform: %s\n"
-                "  Max Packet Size: %zu\n"
                 "  Encrypted: %s\n"
                 "  Ping-pong: %s",
-                this->platform_name_, this->get_max_packet_size(), YESNO(this->is_encrypted_()),
-                YESNO(this->ping_pong_enable_));
+                this->platform_name_, YESNO(this->is_encrypted_()), YESNO(this->ping_pong_enable_));
 #ifdef USE_SENSOR
   for (const auto &sensor : this->sensors_) {
     ESP_LOGCONFIG(TAG, "  Sensor: %s", sensor.id);

esphome/components/runtime_image/jpeg_decoder.cpp

@@ -138,7 +138,7 @@ int HOT JpegDecoder::decode(uint8_t *buffer, size_t size) {
   const int err = this->start_();
   if (err != 0)
     return err;
-  if (!this->jpeg_.decode(0, 0, this->scale_option_()))
+  if (!this->jpeg_.decode(0, 0, 0))
     return this->fail_();
   this->decoded_bytes_ = size;
   this->jpeg_.close();
@@ -165,28 +165,10 @@ int JpegDecoder::start_() {
   } else {
     this->jpeg_.setPixelType(RGB8888);
   }
-  const int width = this->jpeg_.getWidth();
-  const int height = this->jpeg_.getHeight();
-  if (!this->set_size(width, height)) {
+  if (!this->set_size(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
     return DECODE_ERROR_OUT_OF_MEMORY;
   }
-  // JPEGDEC can decode at 1/2, 1/4 or 1/8 size for much less work. Use the smallest size that still has at least as
-  // many pixels as the buffer, so a large image shown small is not decoded in full only to be thrown away.
-  const int buffer_width = this->image_->get_buffer_width();
-  const int buffer_height = this->image_->get_buffer_height();
-  this->scale_ = 1;
-  while (this->scale_ < JPEG_SCALE_EIGHTH && width / (this->scale_ * 2) >= buffer_width &&
-         height / (this->scale_ * 2) >= buffer_height) {
-    this->scale_ *= 2;
-  }
-  const int decoded_width = (width + this->scale_ - 1) / this->scale_;
-  const int decoded_height = (height + this->scale_ - 1) / this->scale_;
-  this->x_scale_ = static_cast<double>(buffer_width) / decoded_width;
-  this->y_scale_ = static_cast<double>(buffer_height) / decoded_height;
-  if (this->scale_ != 1) {
-    ESP_LOGD(TAG, "Decoding at 1/%d size, %d x %d", this->scale_, decoded_width, decoded_height);
-  }
-  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(decoded_width, decoded_height)) {
+  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
     return DECODE_ERROR_OUT_OF_MEMORY;
   }
   return 0;
@@ -270,7 +252,7 @@ int JpegDecoder::begin_source(DecodeSource *source) {
     this->source_ = nullptr;
     return err;
   }
-  if (!this->jpeg_.decodeBegin(0, 0, this->scale_option_()))
+  if (!this->jpeg_.decodeBegin(0, 0, 0))
     return this->fail_();
   return 0;
 }

esphome/components/runtime_image/jpeg_decoder.h

@@ -31,16 +31,12 @@ class JpegDecoder : public ImageDecoder {
   int HOT decode_step() override;
 
   bool uses_direct_rgb565() const { return this->direct_rgb565_; }
-  /// JPEGDEC decodes the image at 1/get_scale() of its size: 1, 2, 4 or 8
-  int get_scale() const { return this->scale_; }
   void draw_rgb565(int x, int y, int w, int h, const uint8_t *pixels);
 
  protected:
   bool prepare_rgb565_scaling_(int width, int height);
   /// Set up an opened image for decoding. Returns 0, or a DecodeError.
   int start_();
-  /// The JPEGDEC option for scale_: JPEG_SCALE_HALF, _QUARTER and _EIGHTH are the divisors themselves
-  int scale_option_() const { return this->scale_ == 1 ? 0 : this->scale_; }
   /// The DecodeError for a failed read of the source or JPEGDEC's last error, closing the image
   int fail_();
 
@@ -53,7 +49,6 @@ class JpegDecoder : public ImageDecoder {
   FixedVector<uint16_t> y_boundaries_{};
   int source_width_{0};
   int source_height_{0};
-  int scale_{1};                   // JPEGDEC decodes at 1/scale_ of the image size
   DecodeSource *source_{nullptr};  // Set while a begin_source() decode is in progress
   bool direct_rgb565_{false};
   bool source_failed_{false};

esphome/components/st7305/display.py

@@ -4,7 +4,6 @@ import pkgutil
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display, spi
-from esphome.components.display import CONF_SHOW_TEST_CARD
 from esphome.components.mipi import (
     DriverChip,
     flatten_sequence,
@@ -13,16 +12,13 @@ from esphome.components.mipi import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AUTO_CLEAR_ENABLED,
     CONF_CS_PIN,
     CONF_DATA_RATE,
     CONF_DC_PIN,
     CONF_HEIGHT,
     CONF_ID,
     CONF_INIT_SEQUENCE,
-    CONF_LAMBDA,
     CONF_MODEL,
-    CONF_PAGES,
     CONF_RESET_PIN,
     CONF_ROTATION,
     CONF_WIDTH,
@@ -182,10 +178,7 @@ def customise_schema(config: ConfigType) -> ConfigType:
         config[CONF_HEIGHT],
         has_hardware_rotation=False,
         byte_order=cv.UNDEFINED,
-        has_writer=config.get(CONF_AUTO_CLEAR_ENABLED) is True
-        or config.get(CONF_PAGES) is not None
-        or config.get(CONF_LAMBDA) is not None
-        or config.get(CONF_SHOW_TEST_CARD) is True,
+        has_writer=display.config_has_writer(config),
         rotation=config.get(CONF_ROTATION, 0),
     )
     return config

esphome/components/st7305/st7305.cpp

@@ -56,33 +56,26 @@ void ST7305::reset_() {
 }
 
 void ST7305::send_init_sequence_() {
-  while (this->init_index_ < this->init_sequence_length_) {
-    if (this->init_sequence_length_ - this->init_index_ < 2) {
-      this->mark_failed(LOG_STR("Malformed init sequence"));
-      return;
-    }
-    const uint8_t command = progmem_read_byte(&this->init_sequence_[this->init_index_++]);
-    const uint8_t count = progmem_read_byte(&this->init_sequence_[this->init_index_++]);
-    if (count == 0xFF) {
-      // Resume the sequence after the delay instead of blocking the main loop.
-      this->set_timeout(STARTUP_TIMEOUT_ID, command, [this]() { this->send_init_sequence_(); });
-      return;
-    }
-    if (this->init_sequence_length_ - this->init_index_ < count) {
-      this->mark_failed(LOG_STR("Malformed init sequence"));
-      return;
-    }
+  display::InitSequenceEntry entry;
+  display::InitSequenceStep step;
+  while ((step = this->init_reader_.next(entry)) == display::INIT_SEQUENCE_STEP_COMMAND) {
     this->enable();
-    this->send_command_(command);
-    if (count != 0) {
+    this->send_command_(entry.value);
+    if (entry.count != 0) {
       this->dc_pin_->digital_write(true);
-      for (uint8_t i = 0; i < count; i++)
-        this->write_byte(progmem_read_byte(&this->init_sequence_[this->init_index_ + i]));
+      for (uint8_t i = 0; i < entry.count; i++)
+        this->write_byte(progmem_read_byte(entry.args + i));
     }
     this->disable();
-    this->init_index_ += count;
   }
-  this->finish_init_();
+  if (step == display::INIT_SEQUENCE_STEP_DELAY) {
+    // Resume the sequence after the delay instead of blocking the main loop.
+    this->set_timeout(STARTUP_TIMEOUT_ID, entry.value, [this]() { this->send_init_sequence_(); });
+  } else if (step == display::INIT_SEQUENCE_STEP_MALFORMED) {
+    this->mark_failed(LOG_STR("Malformed init sequence"));
+  } else {
+    this->finish_init_();
+  }
 }
 
 void ST7305::finish_init_() {

esphome/components/st7305/st7305.h

@@ -4,6 +4,7 @@
 #include <cstdint>
 
 #include "esphome/components/display/display_buffer.h"
+#include "esphome/components/display/init_sequence.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
@@ -35,8 +36,7 @@ class ST7305 : public display::DisplayBuffer,
         row_start_(row_start),
         row_end_(row_end),
         buffer_length_(static_cast<size_t>(width) * static_cast<size_t>(height) / 8),
-        init_sequence_(init_sequence),
-        init_sequence_length_(init_sequence_length) {}
+        init_reader_(init_sequence, init_sequence_length) {}
 
   void setup() override;
   void update() override;
@@ -113,9 +113,7 @@ class ST7305 : public display::DisplayBuffer,
   uint8_t row_start_;
   uint8_t row_end_;
   size_t buffer_length_;
-  const uint8_t *init_sequence_;
-  size_t init_sequence_length_;
-  size_t init_index_{0};
+  display::InitSequenceReader init_reader_;
   bool ready_{false};
 
   int x_low_{0};

esphome/components/sx126x/packet_interface/__init__.py

@@ -1,50 +0,0 @@
-from esphome.components import packet_interface
-from esphome.components.packet_interface.radio_link import (
-    new_radio_link,
-    radio_link_final_validate,
-    radio_link_schema,
-)
-import esphome.config_validation as cv
-from esphome.types import ConfigType
-
-from .. import (
-    CONF_MODULATION,
-    CONF_PAYLOAD_LENGTH,
-    CONF_RX_START,
-    CONF_SX126X_ID,
-    CONF_SYNC_VALUE,
-    DOMAIN,
-    SX126x,
-    SX126xListener,
-    sx126x_ns,
-)
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["sx126x"]
-
-SX126xPacketInterface = sx126x_ns.class_(
-    "SX126xPacketInterface", packet_interface.PacketInterface, SX126xListener
-)
-
-CONFIG_SCHEMA = radio_link_schema(SX126xPacketInterface, CONF_SX126X_ID, SX126x)
-
-
-def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
-    """Without LoRa, the radio can tell that a packet is arriving only from its sync word, which listen before talk
-    needs.
-    """
-    if radio[CONF_MODULATION] != "LORA" and not radio[CONF_SYNC_VALUE]:
-        raise cv.Invalid(
-            f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a packet "
-            "is arriving and not send over it",
-            path=[CONF_SX126X_ID],
-        )
-
-
-FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
-    CONF_SX126X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    await new_radio_link(config, CONF_SX126X_ID, DOMAIN)

esphome/components/sx126x/packet_interface/sx126x_packet_interface.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "esphome/components/packet_interface/radio_link.h"
-#include "esphome/components/sx126x/sx126x.h"
-
-namespace esphome::sx126x {
-
-using SX126xPacketInterface = packet_interface::RadioLink<SX126x, SX126xListener, SX126xError, SX126X_MAX_PACKET_SIZE>;
-
-}  // namespace esphome::sx126x

esphome/components/sx126x/sx126x.cpp

@@ -1,7 +1,6 @@
 #include "sx126x.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::sx126x {
@@ -403,15 +402,6 @@ void SX126x::loop() {
   }
 }
 
-bool SX126x::is_receiving() {
-  // DIO1 signals a received packet, which sending would overwrite in the radio's buffer
-  if (this->dio1_pin_->digital_read())
-    return true;
-  uint8_t buf[2];
-  this->read_opcode_(RADIO_GET_IRQSTATUS, buf, 2);
-  return (encode_uint16(buf[0], buf[1]) & (IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID)) != 0;
-}
-
 void SX126x::run_image_cal() {
   // the following values were taken from section 9.2.1 table 9-2
   // in rev 2.1 of the datasheet
@@ -440,11 +430,10 @@ void SX126x::run_image_cal() {
 void SX126x::set_mode_rx() {
   uint8_t buf[8];
 
-  // configure irq params; a valid header or sync word is flagged for is_receiving(), but not signalled on DIO1
+  // configure irq params
   uint16_t irq = IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR;
-  uint16_t flags = irq | IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID;
-  buf[0] = (flags >> 8) & 0xFF;
-  buf[1] = (flags >> 0) & 0xFF;
+  buf[0] = (irq >> 8) & 0xFF;
+  buf[1] = (irq >> 0) & 0xFF;
   buf[2] = (irq >> 8) & 0xFF;
   buf[3] = (irq >> 0) & 0xFF;
   buf[4] = (IRQ_RADIO_NONE >> 8) & 0xFF;

esphome/components/sx126x/sx126x.h

@@ -104,8 +104,6 @@ class SX126x final : public Component,
     return this->transmit_packet(packet.data(), packet.size());
   }
   void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
-  /// True while a packet is being received, or has been received and not yet read; sending would lose it.
-  bool is_receiving();
   Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:

esphome/components/sx127x/packet_interface/__init__.py

@@ -1,68 +0,0 @@
-from esphome.components import packet_interface
-from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE
-from esphome.components.packet_interface.radio_link import (
-    new_radio_link,
-    radio_link_final_validate,
-    radio_link_schema,
-)
-import esphome.config_validation as cv
-from esphome.types import ConfigType
-
-from .. import (
-    CONF_MODULATION,
-    CONF_PACKET_MODE,
-    CONF_PAYLOAD_LENGTH,
-    CONF_RX_START,
-    CONF_SX127X_ID,
-    CONF_SYNC_VALUE,
-    DOMAIN,
-    SX127x,
-    SX127xListener,
-    sx127x_ns,
-)
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["sx127x"]
-
-# The FIFO limit outside LoRa mode
-FSK_MAX_PACKET_SIZE = 64
-
-SX127xPacketInterface = sx127x_ns.class_(
-    "SX127xPacketInterface", packet_interface.PacketInterface, SX127xListener
-)
-
-CONFIG_SCHEMA = radio_link_schema(SX127xPacketInterface, CONF_SX127X_ID, SX127x)
-
-
-def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
-    """Without LoRa, the radio must send packets, not a continuous bit stream, and holds fewer bytes.
-
-    It can tell that a packet is arriving only from its sync word, which listen before talk needs.
-    """
-    if radio[CONF_MODULATION] == "LORA":
-        return
-    if not radio.get(CONF_PACKET_MODE, False):
-        raise cv.Invalid(
-            f"Without LoRa modulation the radio's '{CONF_PACKET_MODE}' must be true, as a link sends packets",
-            path=[CONF_SX127X_ID],
-        )
-    if not radio.get(CONF_SYNC_VALUE):
-        raise cv.Invalid(
-            f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a "
-            "packet is arriving and not send over it",
-            path=[CONF_SX127X_ID],
-        )
-    if config[CONF_MAX_PACKET_SIZE] > FSK_MAX_PACKET_SIZE:
-        raise cv.Invalid(
-            f"Without LoRa modulation the radio sends at most {FSK_MAX_PACKET_SIZE} bytes",
-            path=[CONF_MAX_PACKET_SIZE],
-        )
-
-
-FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
-    CONF_SX127X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    await new_radio_link(config, CONF_SX127X_ID, DOMAIN)

esphome/components/sx127x/packet_interface/sx127x_packet_interface.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include "esphome/components/packet_interface/radio_link.h"
-#include "esphome/components/sx127x/sx127x.h"
-
-namespace esphome::sx127x {
-
-using SX127xPacketInterface = packet_interface::RadioLink<SX127x, SX127xListener, SX127xError, SX127X_MAX_PACKET_SIZE>;
-
-}  // namespace esphome::sx127x

esphome/components/sx127x/sx127x.cpp

@@ -354,18 +354,6 @@ void SX127x::loop() {
   }
 }
 
-bool SX127x::is_receiving() {
-  // In receive mode DIO0 signals a received packet; the transmit FIFO would overwrite it
-  if (this->dio0_pin_ != nullptr && this->dio0_pin_->digital_read())
-    return true;
-  if (this->modulation_ != MOD_LORA) {
-    // Set from the sync word until the packet has been read; the preamble flag stays set when no sync word follows
-    return (this->read_register_(REG_IRQ_FLAGS_1) & IRQ_FLAGS_1_SYNC_ADDRESS_MATCH) != 0;
-  }
-  return (this->read_register_(REG_MODEM_STAT) &
-          (MODEM_STAT_SIGNAL_DETECTED | MODEM_STAT_SIGNAL_SYNCHRONIZED | MODEM_STAT_HEADER_VALID)) != 0;
-}
-
 void SX127x::run_image_cal() {
   if (this->modulation_ == MOD_LORA) {
     this->set_mode_(MOD_FSK, MODE_SLEEP);

esphome/components/sx127x/sx127x.h

@@ -88,8 +88,6 @@ class SX127x final : public Component,
     return this->transmit_packet(packet.data(), packet.size());
   }
   void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
-  /// True while a packet is being received, or has been received and not yet read; sending would lose it.
-  bool is_receiving();
   Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:

esphome/components/sx127x/sx127x_reg.h

@@ -45,7 +45,6 @@ enum SX127xReg : uint8_t {
   REG_PAYLOAD_LENGTH_LSB = 0x32,
   REG_FIFO_THRESH = 0x35,
   REG_IMAGE_CAL = 0x3B,
-  REG_IRQ_FLAGS_1 = 0x3E,
   // LoRa registers
   REG_FIFO_ADDR_PTR = 0x0D,
   REG_FIFO_TX_BASE_ADDR = 0x0E,
@@ -260,17 +259,6 @@ enum SX127xIrqFlags : uint8_t {
   CAD_DETECTED = 0x01,
 };
 
-enum SX127xIrqFlags1 : uint8_t {
-  IRQ_FLAGS_1_PREAMBLE_DETECT = 0x02,
-  IRQ_FLAGS_1_SYNC_ADDRESS_MATCH = 0x01,
-};
-
-enum SX127xModemStat : uint8_t {
-  MODEM_STAT_SIGNAL_DETECTED = 0x01,
-  MODEM_STAT_SIGNAL_SYNCHRONIZED = 0x02,
-  MODEM_STAT_HEADER_VALID = 0x08,
-};
-
 enum SX127xModemCfg1 : uint8_t {
   BW_7_8 = 0x00,
   BW_10_4 = 0x10,

esphome/components/syslog/esphome_syslog.cpp

@@ -19,52 +19,6 @@ static constexpr uint8_t LOG_LEVEL_TO_SYSLOG_SEVERITY[] PROGMEM = {
     7   // VERY_VERBOSE
 };
 
-static constexpr char SECRET_BEGIN[] = ESPHOME_LOG_SECRET_BEGIN;
-static constexpr char SECRET_END[] = ESPHOME_LOG_SECRET_END;
-static constexpr size_t SECRET_BEGIN_LEN = sizeof(SECRET_BEGIN) - 1;
-static constexpr size_t SECRET_END_LEN = sizeof(SECRET_END) - 1;
-
-static bool starts_with_marker(const char *message, size_t remaining, const char *marker, size_t marker_len) {
-  return message[0] == '\033' && remaining >= marker_len && memcmp(message, marker, marker_len) == 0;
-}
-
-static size_t append_bytes(char *buf, size_t size, size_t pos, const char *data, size_t len) {
-  if (pos >= size) {
-    return size;
-  }
-  size_t n = std::min(len, size - pos - 1);
-  memcpy(buf + pos, data, n);
-  pos += n;
-  buf[pos] = '\0';
-  return pos;
-}
-
-size_t append_redacted_message(char *buf, size_t size, size_t pos, const char *message, size_t len) {
-  if (memchr(message, '\033', len) == nullptr) {
-    return append_bytes(buf, size, pos, message, len);
-  }
-  size_t i = 0;
-  while (i < len) {
-    if (starts_with_marker(message + i, len - i, SECRET_BEGIN, SECRET_BEGIN_LEN)) {
-      pos = buf_append_str(buf, size, pos, "[redacted]");
-      i += SECRET_BEGIN_LEN;
-      while (i < len && !starts_with_marker(message + i, len - i, SECRET_END, SECRET_END_LEN)) {
-        i++;
-      }
-      if (i < len) {
-        i += SECRET_END_LEN;
-      }
-      continue;
-    }
-    size_t start = i;
-    while (i < len && !starts_with_marker(message + i, len - i, SECRET_BEGIN, SECRET_BEGIN_LEN)) {
-      i++;
-    }
-    pos = append_bytes(buf, size, pos, message + start, i - start);
-  }
-  return pos;
-}
-
 void Syslog::setup() {
   logger::global_logger->add_log_callback(
       this, [](void *self, uint8_t level, const char *tag, const char *message, size_t message_len) {
@@ -117,15 +71,16 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
     } else {
       offset = buf_append_str(packet, sizeof(packet), offset, "-");
     }
-    offset = buf_append_printf(packet, sizeof(packet), offset, " %s %s - - - ", App.get_name().c_str(), tag);
+    offset = buf_append_printf(packet, sizeof(packet), offset, " %s %s - - - %.*s", App.get_name().c_str(), tag,
+                               (int) len, message);
   } else {
     // RFC 3164 has no NILVALUE. If the clock is invalid, omit TIMESTAMP so a relay can add it.
     if (now.is_valid()) {
       offset += now.strftime(packet + offset, sizeof(packet) - offset, "%b %e %H:%M:%S ");
     }
-    offset = buf_append_printf(packet, sizeof(packet), offset, "%s %s: ", App.get_name().c_str(), tag);
+    offset = buf_append_printf(packet, sizeof(packet), offset, "%s %s: %.*s", App.get_name().c_str(), tag, (int) len,
+                               message);
   }
-  offset = append_redacted_message(packet, sizeof(packet), offset, message, len);
   // Clamp to exclude null terminator position if buffer was filled
   if (offset >= sizeof(packet)) {
     offset = sizeof(packet) - 1;

esphome/components/syslog/esphome_syslog.h

@@ -12,10 +12,6 @@ enum SyslogFormat : uint8_t {
   SYSLOG_FORMAT_RFC5424,
 };
 
-/// Append len bytes of message to buf at pos, replacing every LOG_SECRET() region with "[redacted]".
-/// Returns the new position, capped at size like the other buf_append helpers.
-size_t append_redacted_message(char *buf, size_t size, size_t pos, const char *message, size_t len);
-
 class Syslog final : public Component, public Parented<udp::UDPComponent> {
  public:
   Syslog(int level, time::RealTimeClock *time) : log_level_(level), time_(time) {}

esphome/components/tcp/__init__.py

@@ -1,4 +0,0 @@
-"""TCP links. The packet_interface platform carries packets over a TCP connection."""
-
-CODEOWNERS = ["@clydebarrow"]
-DOMAIN = "tcp"

esphome/components/tcp/packet_interface/__init__.py

@@ -1,134 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import binary_sensor, packet_interface, socket
-from esphome.components.const import (
-    CONF_ALLOWED_IPS,
-    CONF_CONNECTED,
-    CONF_HOST,
-    CONF_RECONNECT_INTERVAL,
-    CONF_ROLE,
-)
-from esphome.components.packet_interface import (
-    CONF_MAX_PACKET_SIZE,
-    new_packet_interface,
-    packet_interface_schema,
-)
-from esphome.components.packet_interface.layers import (
-    CONF_ADDRESSING,
-    CONF_RELIABILITY,
-    CONF_SESSION,
-)
-from esphome.components.packet_interface.layers.basic_session import CONF_KEEP_ALIVE
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    CONF_PORT,
-    CONF_TIMEOUT,
-    DEVICE_CLASS_CONNECTIVITY,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-)
-from esphome.types import ConfigType
-
-CODEOWNERS = ["@clydebarrow"]
-DEPENDENCIES = ["network"]
-
-
-def AUTO_LOAD(config: ConfigType | None = None) -> list[str]:
-    """The binary_sensor component only for the connected sensor; without a config, as tooling calls it, both."""
-    if not config or CONF_CONNECTED in config:
-        return ["socket", "binary_sensor"]
-    return ["socket"]
-
-
-# Each packet and its 2 byte length must fit the socket link's 1024 byte send buffer
-MAX_PACKET_SIZE = 1022
-
-tcp_ns = cg.esphome_ns.namespace("tcp")
-TcpPacketInterface = tcp_ns.class_(
-    "TcpPacketInterface", packet_interface.PacketInterface
-)
-
-
-def _timeout(config: ConfigType) -> ConfigType:
-    """Default the timeout to three keep-alive intervals, and require it to be longer than one."""
-    keep_alive = config[CONF_KEEP_ALIVE].total_milliseconds
-    if (timeout := config.get(CONF_TIMEOUT)) is None:
-        config[CONF_TIMEOUT] = cv.positive_time_period_milliseconds(
-            f"{keep_alive * 3}ms"
-        )
-    elif timeout.total_milliseconds <= keep_alive:
-        raise cv.Invalid("Must be longer than keep_alive", path=[CONF_TIMEOUT])
-    return config
-
-
-BASE_SCHEMA = packet_interface_schema(
-    TcpPacketInterface,
-    MAX_PACKET_SIZE,
-    MAX_PACKET_SIZE,
-    # TCP resends what is lost, joins exactly two devices, and its connection state is the session
-    provides=(CONF_ADDRESSING, CONF_RELIABILITY, CONF_SESSION),
-).extend(
-    {
-        cv.Required(CONF_PORT): cv.port,
-        cv.Optional(
-            CONF_RECONNECT_INTERVAL, default="5s"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_KEEP_ALIVE, default="10s"): cv.All(
-            cv.positive_time_period_milliseconds,
-            cv.Range(min=cv.TimePeriod(seconds=1), max=cv.TimePeriod(hours=1)),
-        ),
-        # Nothing received for this long closes the connection; it must be longer than the peer's keep_alive
-        cv.Optional(CONF_TIMEOUT): cv.All(
-            cv.positive_time_period_milliseconds,
-            cv.Range(max=cv.TimePeriod(hours=3)),
-        ),
-        cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
-            device_class=DEVICE_CLASS_CONNECTIVITY,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-    }
-)
-
-CONFIG_SCHEMA = cv.All(
-    cv.typed_schema(
-        {
-            "client": cv.All(
-                BASE_SCHEMA.extend({cv.Required(CONF_HOST): socket.ipv4_host}),
-                _timeout,
-            ),
-            "server": cv.All(
-                BASE_SCHEMA.extend(
-                    {cv.Optional(CONF_ALLOWED_IPS): socket.IPV4_ALLOW_SCHEMA}
-                ),
-                _timeout,
-            ),
-        },
-        key=CONF_ROLE,
-        default_type="client",
-    ),
-    # A client uses one socket; a server one listener and one accepted socket
-    socket.consume_role_sockets("tcp.packet_interface"),
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    # The receive buffer's size is known here, so it is a static array rather than allocated at run time
-    rx_buffer = f"{config[CONF_ID].id}__rx_buffer"
-    cg.add_global(
-        cg.RawStatement(f"static uint8_t {rx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
-    )
-    var = await new_packet_interface(config, cg.RawExpression(rx_buffer))
-    if config[CONF_ROLE] == "server":
-        socket.require_tcp_listener()
-        cg.add(var.set_server(True))
-        socket.add_ipv4_allow(
-            var.set_allow, config.get(CONF_ALLOWED_IPS), config[CONF_ID]
-        )
-    else:
-        socket.require_tcp_client_link()
-        cg.add(var.set_host(config[CONF_HOST]))
-    cg.add(var.set_port(config[CONF_PORT]))
-    cg.add(var.set_reconnect_interval(config[CONF_RECONNECT_INTERVAL]))
-    cg.add(var.set_keep_alive(config[CONF_KEEP_ALIVE]))
-    cg.add(var.set_receive_timeout(config[CONF_TIMEOUT]))
-    binary_sensors = binary_sensor.sub_binary_sensors(config)
-    await binary_sensors(CONF_CONNECTED, var.set_connected_sensor)

esphome/components/tcp/packet_interface/tcp_packet_interface.cpp

@@ -1,169 +0,0 @@
-#include "tcp_packet_interface.h"
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::tcp {
-
-using packet_interface::PacketBuffer;
-using packet_interface::PacketMetaData;
-
-ESPHOME_LOG_TAG(TAG, "tcp.packet_interface");
-
-// The packet length before each packet
-static constexpr size_t LENGTH_SIZE = 2;
-
-TcpPacketInterface::TcpPacketInterface(std::span<uint8_t> rx_buffer)
-    : packet_interface::PacketInterface(rx_buffer.size()), rx_buffer_(rx_buffer) {
-  this->capabilities_ = packet_interface::CAPABILITY_RELIABILITY | packet_interface::CAPABILITY_SESSION |
-                        packet_interface::CAPABILITY_ADDRESSING;
-}
-
-void TcpPacketInterface::setup() {
-  this->link_.begin(TAG);
-#ifdef USE_SOCKET_TCP_LISTENER
-  this->listener_.begin(TAG);
-#endif
-#ifdef USE_BINARY_SENSOR
-  if (this->connected_sensor_ != nullptr)
-    this->connected_sensor_->publish_initial_state(false);
-#endif
-}
-
-void TcpPacketInterface::dump_config() {
-  bool server = false;
-#ifdef USE_SOCKET_TCP_LISTENER
-  server = this->server_;
-#endif
-  ESP_LOGCONFIG(TAG,
-                "TCP Packet Interface '%s':\n"
-                "  Role: %s\n"
-                "  Address: %s:%u\n"
-                "  Reconnect Interval: %" PRIu32 "ms\n"
-                "  Keep Alive: %" PRIu32 "ms\n"
-                "  Timeout: %" PRIu32 "ms\n"
-                "  Max Packet Size: %zu",
-                this->name_, server ? LOG_STR_LITERAL("server") : LOG_STR_LITERAL("client"),
-                server ? LOG_STR_LITERAL("*") : this->link_.host(), this->link_.port(),
-                this->link_.reconnect_interval(), this->keep_alive_ms_, this->timeout_ms_, this->max_packet_size_);
-#ifdef USE_SOCKET_TCP_LISTENER
-  this->listener_.dump_config();
-#endif
-#ifdef USE_BINARY_SENSOR
-  LOG_BINARY_SENSOR("  ", "Connected", this->connected_sensor_);
-#endif
-}
-
-void TcpPacketInterface::on_shutdown() {
-  this->link_.close();
-#ifdef USE_SOCKET_TCP_LISTENER
-  this->listener_.close();
-#endif
-}
-
-void TcpPacketInterface::loop() {
-#ifdef USE_SOCKET_TCP_LISTENER
-  if (this->server_) {
-    // A new client is accepted only once the drop of the last has been reported
-    this->listener_.poll(this->link_, !this->connected_);
-  } else {
-    this->link_.poll();
-  }
-#else
-  this->link_.poll();
-#endif
-  if (this->link_.connected() != this->connected_)
-    this->on_connection_(this->link_.connected());
-  if (!this->connected_)
-    return;
-  this->read_();
-  if (!this->connected_)
-    return;
-  uint32_t now = App.get_loop_component_start_time();
-  if (now - this->last_rx_ms_ > this->timeout_ms_) {
-    ESP_LOGW(TAG, "%s: Nothing received for %" PRIu32 "ms, closing the connection", this->name_, this->timeout_ms_);
-    this->link_.close();
-    this->link_.note_attempt();
-    this->on_connection_(false);
-    return;
-  }
-  if (now - this->last_tx_ms_ >= this->keep_alive_ms_)
-    this->queue_frame_(nullptr, 0);
-  this->link_.flush_tx();
-}
-
-void TcpPacketInterface::on_connection_(bool connected) {
-  ESP_LOGD(TAG, "%s: Connection %s", this->name_, connected ? LOG_STR_LITERAL("up") : LOG_STR_LITERAL("down"));
-  this->connected_ = connected;
-  this->rx_have_ = 0;
-  this->last_rx_ms_ = this->last_tx_ms_ = App.get_loop_component_start_time();
-#ifdef USE_BINARY_SENSOR
-  if (this->connected_sensor_ != nullptr)
-    this->connected_sensor_->publish_state(connected);
-#endif
-  this->session_callback_.call(connected);
-}
-
-void TcpPacketInterface::read_() {
-  for (;;) {
-    ssize_t count;
-    if (this->rx_have_ < LENGTH_SIZE) {
-      count = this->link_.read(this->rx_header_ + this->rx_have_, LENGTH_SIZE - this->rx_have_);
-    } else {
-      count = this->link_.read(this->rx_buffer_.data() + this->rx_have_ - LENGTH_SIZE,
-                               this->rx_length_ + LENGTH_SIZE - this->rx_have_);
-    }
-    // Nothing more for now; a dropped link is seen on the next loop
-    if (count <= 0)
-      return;
-    this->last_rx_ms_ = App.get_loop_component_start_time();
-    this->rx_have_ += count;
-    if (this->rx_have_ < LENGTH_SIZE)
-      continue;
-    if (this->rx_have_ == LENGTH_SIZE) {
-      this->rx_length_ = encode_uint16(this->rx_header_[1], this->rx_header_[0]);
-      if (this->rx_length_ > this->max_packet_size_) {
-        // The stream cannot be resynchronised, so start a new connection
-        ESP_LOGW(TAG, "%s: Packet of %u bytes is larger than %zu, closing the connection", this->name_,
-                 this->rx_length_, this->max_packet_size_);
-        this->link_.close();
-        this->link_.note_attempt();
-        this->on_connection_(false);
-        return;
-      }
-    }
-    if (this->rx_have_ == this->rx_length_ + LENGTH_SIZE) {
-      this->rx_have_ = 0;
-      // A zero length packet is a keep-alive
-      if (this->rx_length_ != 0)
-        this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_.data(), this->rx_length_), {});
-    }
-  }
-}
-
-bool TcpPacketInterface::queue_frame_(const PacketBuffer *data, size_t size) {
-  if (this->link_.tx_free() < size + LENGTH_SIZE)
-    return false;
-  uint8_t *tail = this->link_.tx_tail();
-  tail[0] = static_cast<uint8_t>(size);
-  tail[1] = static_cast<uint8_t>(size >> 8);
-  if (data != nullptr)
-    data->copy_to(tail + LENGTH_SIZE, size);
-  this->link_.tx_commit(size + LENGTH_SIZE);
-  this->last_tx_ms_ = App.get_loop_component_start_time();
-  return true;
-}
-
-bool TcpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  if (!this->connected_ || !this->queue_frame_(&data, size))
-    return false;
-  this->link_.flush_tx();
-  return true;
-}
-
-}  // namespace esphome::tcp

esphome/components/tcp/packet_interface/tcp_packet_interface.h

@@ -1,87 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <span>
-
-#include "esphome/components/packet_interface/packet_interface.h"
-#include "esphome/components/socket/tcp_client_link.h"
-#ifdef USE_SOCKET_TCP_LISTENER
-#include "esphome/components/socket/tcp_listener.h"
-#endif
-#ifdef USE_BINARY_SENSOR
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#endif
-
-namespace esphome::tcp {
-
-/**
- * A packet interface link over one TCP connection, as a client that connects to a host, or a server that accepts
- * one client at a time.
- *
- * Each packet is sent as a 2 byte length, little endian, then the packet. TCP delivers the stream in order and
- * resends what is lost, and the connection joins exactly two devices, so the link provides the reliability,
- * addressing and session capabilities itself. Its connection state is the session state.
- *
- * Each packet is written to the socket as it is sent, so the link takes packets as fast as the socket does and keeps
- * the default, unlimited, send capacity; a packet is refused only while the connection is down or the socket is full.
- *
- * A zero length packet is a keep-alive, sent when nothing else has been sent for keep_alive. TCP can take minutes to
- * notice a peer that has gone without closing the connection, so the link closes it, and reconnects or accepts again,
- * when nothing has been received for the timeout, which must be longer than the peer's keep-alive interval.
- */
-class TcpPacketInterface : public packet_interface::PacketInterface {
- public:
-  /// @param rx_buffer Holds the packet being received; its size is the largest packet, and it must outlive the link
-  explicit TcpPacketInterface(std::span<uint8_t> rx_buffer);
-
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-  void on_shutdown() override;
-  bool send_to_interface(const packet_interface::PacketBuffer &data,
-                         const packet_interface::PacketMetaData &meta_data) override;
-
-  void set_host(const char *host) { this->link_.set_host(host); }
-  void set_port(uint16_t port) { this->link_.set_port(port); }
-  void set_reconnect_interval(uint32_t interval_ms) { this->link_.set_reconnect_interval(interval_ms); }
-  void set_keep_alive(uint32_t keep_alive_ms) { this->keep_alive_ms_ = keep_alive_ms; }
-  /// The connection is closed when nothing has been received for this long; the peer's keep_alive sets the pace.
-  void set_receive_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
-#ifdef USE_SOCKET_TCP_LISTENER
-  void set_server(bool server) { this->server_ = server; }
-#ifdef USE_SOCKET_IPV4_ALLOW
-  void set_allow(const socket::Ipv4AllowEntry *entries, size_t count) { this->listener_.set_allow(entries, count); }
-#endif
-#endif
-#ifdef USE_BINARY_SENSOR
-  void set_connected_sensor(binary_sensor::BinarySensor *sensor) { this->connected_sensor_ = sensor; }
-#endif
-
-  bool is_connected() const { return this->connected_; }
-
- protected:
-  void on_connection_(bool connected);
-  void read_();
-  bool queue_frame_(const packet_interface::PacketBuffer *data, size_t size);
-
-  socket::TcpClientLink link_;
-#ifdef USE_SOCKET_TCP_LISTENER
-  socket::TcpListener listener_;
-  bool server_{false};
-#endif
-#ifdef USE_BINARY_SENSOR
-  binary_sensor::BinarySensor *connected_sensor_{nullptr};
-#endif
-  const std::span<uint8_t> rx_buffer_;
-  uint32_t keep_alive_ms_{10000};
-  uint32_t timeout_ms_{30000};
-  uint32_t last_rx_ms_{0};
-  uint32_t last_tx_ms_{0};
-  uint16_t rx_length_{0};
-  // Bytes of the current frame received so far, counting the 2 byte length
-  uint16_t rx_have_{0};
-  uint8_t rx_header_[2]{};
-  bool connected_{false};
-};
-
-}  // namespace esphome::tcp

esphome/components/uart/packet_interface/__init__.py

@@ -1,36 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import packet_interface, uart
-from esphome.components.packet_interface import (
-    CONF_MAX_PACKET_SIZE,
-    packet_interface_schema,
-)
-from esphome.const import CONF_ID
-from esphome.types import ConfigType
-
-from .. import uart_ns
-
-CODEOWNERS = ["@clydebarrow"]
-
-DEPENDENCIES = ["uart"]
-
-UartPacketInterface = uart_ns.class_(
-    "UartPacketInterface",
-    packet_interface.PacketInterface,
-    uart.UARTDevice,
-)
-
-CONFIG_SCHEMA = packet_interface_schema(UartPacketInterface, 508).extend(
-    uart.UART_DEVICE_SCHEMA
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    # The receive buffer's size is known here, so it is a static array rather than allocated at run time
-    rx_buffer = f"{config[CONF_ID].id}__rx_buffer"
-    cg.add_global(
-        cg.RawStatement(f"static uint8_t {rx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
-    )
-    var = await packet_interface.new_packet_interface(
-        config, cg.RawExpression(rx_buffer)
-    )
-    await uart.register_uart_device(var, config)

esphome/components/uart/packet_interface/uart_packet_interface.cpp

@@ -1,82 +0,0 @@
-#include "esphome/core/log.h"
-#include "uart_packet_interface.h"
-
-namespace esphome::uart {
-
-using packet_interface::PacketBuffer;
-using packet_interface::PacketMetaData;
-
-ESPHOME_LOG_TAG(TAG, "uart.packet_interface");
-
-static constexpr uint8_t FLAG_BYTE = 0x7E;
-static constexpr uint8_t CONTROL_BYTE = 0x7D;
-static constexpr uint8_t ESCAPE_XOR = 0x20;
-// Raw bytes escaped and written per UART write
-static constexpr size_t TX_CHUNK_SIZE = 32;
-
-void UartPacketInterface::loop() {
-  this->read_available([this](uint8_t byte) { this->handle_rx_byte_(byte); });
-}
-
-void UartPacketInterface::handle_rx_byte_(uint8_t byte) {
-  if (byte == FLAG_BYTE) {
-    // A flag that ends a frame also starts the next, so an unfinished frame cannot hide the one after it
-    if (this->rx_started_ && this->rx_length_ != 0)
-      this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_.data(), this->rx_length_), {});
-    this->rx_started_ = true;
-    this->rx_length_ = 0;
-    this->rx_control_ = false;
-    return;
-  }
-  if (!this->rx_started_)
-    return;
-  if (byte == CONTROL_BYTE) {
-    this->rx_control_ = true;
-    return;
-  }
-  if (this->rx_control_) {
-    byte ^= ESCAPE_XOR;
-    this->rx_control_ = false;
-  }
-  if (this->rx_length_ >= this->rx_buffer_.size()) {
-    ESP_LOGD(TAG, "Packet too large, discarding");
-    this->rx_started_ = false;
-    this->rx_length_ = 0;
-    return;
-  }
-  this->rx_buffer_[this->rx_length_++] = byte;
-}
-
-bool UartPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  size_t size = data.size();
-  if (size == 0)
-    return true;
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "Packet of %zu bytes is larger than %zu", size, this->max_packet_size_);
-    return false;
-  }
-  uint8_t raw[TX_CHUNK_SIZE]{};
-  // Every byte may be escaped, plus a flag byte at each end
-  uint8_t out[TX_CHUNK_SIZE * 2 + 2];
-  size_t out_len = 0;
-  out[out_len++] = FLAG_BYTE;
-  for (size_t offset = 0; offset < size;) {
-    size_t count = data.copy_to(raw, TX_CHUNK_SIZE, offset);
-    offset += count;
-    for (size_t i = 0; i != count; i++) {
-      uint8_t byte = raw[i];
-      if (byte == FLAG_BYTE || byte == CONTROL_BYTE) {
-        out[out_len++] = CONTROL_BYTE;
-        byte ^= ESCAPE_XOR;
-      }
-      out[out_len++] = byte;
-    }
-    if (offset == size)
-      out[out_len++] = FLAG_BYTE;
-    this->write_array(out, out_len);
-    out_len = 0;
-  }
-  return true;
-}
-
-}  // namespace esphome::uart

esphome/components/uart/packet_interface/uart_packet_interface.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <span>
-
-#include "esphome/components/packet_interface/packet_interface.h"
-#include "esphome/components/uart/uart.h"
-
-namespace esphome::uart {
-
-/**
- * A packet interface for sending and receiving framed packets over a UART connection.
- * Uses simple byte-stuffing framing with FLAG_BYTE and CONTROL_BYTE.
- * The protocol wraps 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.
- */
-class UartPacketInterface : public packet_interface::PacketInterface, public UARTDevice {
- public:
-  /// @param rx_buffer Holds the unescaped data being received; its size is the largest packet, and it must outlive
-  /// the link
-  explicit UartPacketInterface(std::span<uint8_t> rx_buffer)
-      : packet_interface::PacketInterface(rx_buffer.size()), rx_buffer_(rx_buffer) {}
-
-  void loop() override;
-  bool send_to_interface(const packet_interface::PacketBuffer &data,
-                         const packet_interface::PacketMetaData &meta_data) override;
-
- protected:
-  void handle_rx_byte_(uint8_t byte);
-  const std::span<uint8_t> rx_buffer_;
-  size_t rx_length_{0};
-  bool rx_started_{};
-  bool rx_control_{};
-};
-
-}  // namespace esphome::uart

esphome/components/uart/packet_transport/uart_transport.cpp

@@ -6,10 +6,6 @@ namespace esphome::uart {
 
 ESPHOME_LOG_TAG(TAG, "uart_transport");
 
-static constexpr uint16_t MAX_PACKET_SIZE = 508;
-static constexpr uint8_t FLAG_BYTE = 0x7E;
-static constexpr uint8_t CONTROL_BYTE = 0x7D;
-
 void UARTTransport::loop() {
   PacketTransport::loop();
 
@@ -82,5 +78,4 @@ void UARTTransport::send_packet(const std::vector<uint8_t> &buf) const {
   this->parent_->write_byte(FLAG_BYTE);
 }
 
-size_t UARTTransport::get_max_packet_size() { return MAX_PACKET_SIZE; }
 }  // namespace esphome::uart

esphome/components/uart/packet_transport/uart_transport.h

@@ -16,6 +16,9 @@ namespace esphome::uart {
  * 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 final : public packet_transport::PacketTransport, public UARTDevice {
  public:
@@ -26,7 +29,7 @@ class UARTTransport final : public packet_transport::PacketTransport, public UAR
   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;
+  size_t get_max_packet_size() override { return MAX_PACKET_SIZE; }
   std::vector<uint8_t> receive_buffer_{};
   bool rx_started_{};
   bool rx_control_{};

esphome/components/udp/packet_interface/__init__.py

@@ -1,103 +0,0 @@
-from ipaddress import IPv4Address
-
-import esphome.codegen as cg
-from esphome.components import packet_interface
-from esphome.components.packet_interface import (
-    CONF_MAX_PACKET_SIZE,
-    new_packet_interface,
-    packet_interface_schema,
-)
-from esphome.components.packet_interface.layers import (
-    CONF_ADDRESSING,
-    check_broadcast_link,
-)
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.core import CORE, HexInt
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from .. import CONF_ADDRESSES, CONF_UDP_ID, DOMAIN as UDP_DOMAIN, UDP_SCHEMA, udp_ns
-
-CODEOWNERS = ["@clydebarrow"]
-
-DEPENDENCIES = ["udp"]
-
-CONF_POINT_TO_POINT = "point_to_point"
-
-# Size of the receive buffer of the udp component
-MAX_PACKET_SIZE = 508
-
-UdpPacketInterface = udp_ns.class_(
-    "UdpPacketInterface",
-    packet_interface.PacketInterface,
-)
-
-CONFIG_SCHEMA = (
-    packet_interface_schema(UdpPacketInterface, MAX_PACKET_SIZE, MAX_PACKET_SIZE)
-    .extend(UDP_SCHEMA)
-    .extend(
-        {
-            # Overrides the guess from the udp component's addresses, which cannot see the subnet
-            cv.Optional(CONF_POINT_TO_POINT): cv.boolean,
-        }
-    )
-)
-
-
-def _peer(udp_config: ConfigType, config: ConfigType) -> IPv4Address | None:
-    """The one peer, when the UDP component sends to a single unicast IPv4 address.
-
-    Unless point_to_point says otherwise, an address ending in .255 is taken as a subnet broadcast, as the subnet is
-    not known here.
-    """
-    point_to_point = config.get(CONF_POINT_TO_POINT)
-    match udp_config[CONF_ADDRESSES]:
-        case [IPv4Address() as address] if not address.is_multicast:
-            if point_to_point is None:
-                point_to_point = address.packed[3] != 255
-            return address if point_to_point else None
-    if point_to_point:
-        raise cv.Invalid(
-            f"'{CONF_POINT_TO_POINT}' needs the UDP component to send to one unicast IPv4 address",
-            path=[CONF_POINT_TO_POINT],
-        )
-    return None
-
-
-def _udp_config(full_config: ConfigType, config: ConfigType) -> ConfigType:
-    return next(
-        udp for udp in full_config[UDP_DOMAIN] if udp[CONF_ID] == config[CONF_UDP_ID]
-    )
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    if (peer := _peer(_udp_config(fv.full_config.get(), config), config)) is None:
-        check_broadcast_link(config)
-    elif CONF_ADDRESSING in config:
-        raise cv.Invalid(
-            f"The UDP component sends only to {peer}, so packets are already addressed; "
-            f"'{CONF_ADDRESSING}' is only for broadcast or multicast",
-            path=[CONF_ADDRESSING],
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
-async def to_code(config: ConfigType) -> None:
-    udp_var = await cg.get_variable(config[CONF_UDP_ID])
-    cg.add(udp_var.set_should_listen())
-    # The udp component sends to its addresses through its broadcast socket
-    cg.add(udp_var.set_should_broadcast())
-    peer = _peer(_udp_config(CORE.config, config), config)
-    peer_bytes = peer.packed if peer is not None else bytes(4)
-    # The copy buffer's size is known here, so it is a static array rather than allocated at run time
-    tx_buffer = f"{config[CONF_ID].id}__tx_buffer"
-    cg.add_global(
-        cg.RawStatement(f"static uint8_t {tx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
-    )
-    await new_packet_interface(
-        config, udp_var, cg.RawExpression(tx_buffer), [HexInt(x) for x in peer_bytes]
-    )

esphome/components/udp/packet_interface/udp_packet_interface.cpp

@@ -1,79 +0,0 @@
-#include "udp_packet_interface.h"
-#ifdef USE_NETWORK
-#include <cstring>
-#include "esphome/components/network/util.h"
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-namespace esphome::udp {
-
-using packet_interface::PacketBuffer;
-using packet_interface::PacketMetaData;
-
-ESPHOME_LOG_TAG(TAG, "udp.packet_interface");
-
-UdpPacketInterface::UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer,
-                                       std::array<uint8_t, 4> peer)
-    : packet_interface::PacketInterface(tx_buffer.size()), parent_(udp_component), tx_buffer_(tx_buffer), peer_(peer) {
-  if (this->peer_ != std::array<uint8_t, 4>{})
-    this->capabilities_ = packet_interface::CAPABILITY_ADDRESSING;
-}
-
-void UdpPacketInterface::setup() {
-  this->parent_->add_listener(
-      [this](std::span<const uint8_t> data) { this->receive_(data, this->parent_->get_rx_source()); });
-}
-
-void UdpPacketInterface::receive_(std::span<const uint8_t> data, const sockaddr *source) {
-  if (!this->accepts_from_(source)) {
-    this->warn_dropped_(source);
-    return;
-  }
-  if (data.size() > this->max_packet_size_) {
-    ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu, dropped", this->name_, data.size(),
-             this->max_packet_size_);
-    return;
-  }
-  this->on_receive_from_interface_(PacketBuffer(data.data(), data.size()), {});
-}
-
-bool UdpPacketInterface::accepts_from_(const sockaddr *source) const {
-  if (!this->has_capability(packet_interface::CAPABILITY_ADDRESSING))
-    return true;
-  uint32_t address;
-  return socket::sockaddr_to_ipv4(source, &address) && memcmp(&address, this->peer_.data(), sizeof(address)) == 0;
-}
-
-void UdpPacketInterface::warn_dropped_(const sockaddr *source) {
-  static constexpr uint32_t WARNING_INTERVAL_MS = 60000;
-  uint32_t now = App.get_loop_component_start_time();
-  if (this->drop_warned_ && now - this->last_drop_warning_ms_ < WARNING_INTERVAL_MS)
-    return;
-  this->drop_warned_ = true;
-  this->last_drop_warning_ms_ = now;
-  char from[socket::SOCKADDR_STR_LEN];
-  socket::format_sockaddr_to(source, sizeof(sockaddr_storage), from);
-  ESP_LOGW(TAG,
-           "%s: Packet from %s dropped, as only %u.%u.%u.%u is accepted; set point_to_point: false if that is a "
-           "broadcast address",
-           this->name_, from, this->peer_[0], this->peer_[1], this->peer_[2], this->peer_[3]);
-}
-
-bool UdpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
-  size_t size = data.size();
-  if (size > this->max_packet_size_) {
-    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
-    return false;
-  }
-  if (!network::is_connected())
-    return false;
-  if (data.is_contiguous()) {
-    auto span = data.as_span();
-    return this->parent_->send_packet(span.data(), span.size());
-  }
-  data.copy_to(this->tx_buffer_.data(), size);
-  return this->parent_->send_packet(this->tx_buffer_.data(), size);
-}
-
-}  // namespace esphome::udp
-#endif

esphome/components/udp/packet_interface/udp_packet_interface.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-// udp_component.h declares nothing without USE_NETWORK
-#ifdef USE_NETWORK
-#include <array>
-#include <span>
-
-#include "esphome/components/packet_interface/packet_interface.h"
-#include "esphome/components/socket/socket.h"
-#include "../udp_component.h"
-
-namespace esphome::udp {
-
-/**
- * A packet interface link over UDP: each packet is one datagram, sent to every address of the UDP component.
- *
- * When the UDP component sends to one unicast IPv4 address, the link joins exactly two devices: it accepts packets
- * only from that address, and provides the addressing capability itself. Otherwise every packet is accepted, and an
- * addressing layer can tell the devices apart. Packets from other senders are dropped with a warning at most once a
- * minute, as they suggest that the address is a broadcast address the link took for a device.
- */
-class UdpPacketInterface : public packet_interface::PacketInterface {
- public:
-  /// @param tx_buffer Joins packets split across buffers; its size is the largest packet, and it must outlive the link
-  /// @param peer The IPv4 address of the one peer, in network byte order; all zeros if packets are broadcast
-  UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer, std::array<uint8_t, 4> peer);
-
-  void setup() override;
-  bool send_to_interface(const packet_interface::PacketBuffer &data,
-                         const packet_interface::PacketMetaData &meta_data) override;
-
- protected:
-  void receive_(std::span<const uint8_t> data, const sockaddr *source);
-  /// True if packets from \p source are accepted: from anywhere, or with a peer, only from the peer.
-  bool accepts_from_(const sockaddr *source) const;
-  void warn_dropped_(const sockaddr *source);
-
-  UDPComponent *parent_;
-  const std::span<uint8_t> tx_buffer_;
-  std::array<uint8_t, 4> peer_;
-  uint32_t last_drop_warning_ms_{0};
-  bool drop_warned_{false};
-};
-}  // namespace esphome::udp
-#endif

esphome/components/udp/packet_transport/udp_transport.cpp

@@ -1,9 +1,12 @@
+#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/components/network/util.h"
 #include "udp_transport.h"
 
 namespace esphome::udp {
 
+ESPHOME_LOG_TAG(TAG, "udp_transport");
+
 bool UDPTransport::should_send() { return network::is_connected(); }
 void UDPTransport::setup() {
   PacketTransport::setup();

esphome/components/udp/udp_component.cpp

@@ -205,30 +205,18 @@ void UDPComponent::set_poll_warning_(PollStep step, const LogString *what) {
 }
 
 void UDPComponent::loop() {
-  if (!this->should_listen_) {
-    this->disable_loop();
-    return;
-  }
-  // One byte more than the largest packet, as a read cuts a longer datagram to fit and so cannot report it
-  std::array<uint8_t, MAX_PACKET_SIZE + 1> buf;
-  struct sockaddr_storage source;
-  for (;;) {
-    if (!this->listen_socket_->ready())
-      break;
-    socklen_t source_len = sizeof(source);
-    auto len =
-        this->listen_socket_->recvfrom(buf.data(), buf.size(), reinterpret_cast<sockaddr *>(&source), &source_len);
-    if (len <= 0)
-      break;
-    size_t packet_len = static_cast<size_t>(len);
-    if (packet_len > MAX_PACKET_SIZE) {
-      ESP_LOGV(TAG, "Packet longer than %zu bytes dropped", MAX_PACKET_SIZE);
-      continue;
+  if (this->should_listen_) {
+    std::array<uint8_t, MAX_PACKET_SIZE> buf;
+    for (;;) {
+      if (!this->listen_socket_->ready())
+        break;
+      auto len = this->listen_socket_->read(buf.data(), buf.size());
+      if (len <= 0)
+        break;
+      size_t packet_len = static_cast<size_t>(len);
+      ESP_LOGV(TAG, "Received packet of length %zu", packet_len);
+      this->packet_listeners_.call(std::span<const uint8_t>(buf.data(), packet_len));
     }
-    ESP_LOGV(TAG, "Received packet of length %zu", packet_len);
-    this->rx_source_ = reinterpret_cast<sockaddr *>(&source);
-    this->packet_listeners_.call(std::span<const uint8_t>(buf.data(), packet_len));
-    this->rx_source_ = nullptr;
   }
 }
 
@@ -251,10 +239,9 @@ void UDPComponent::dump_config() {
                 YESNO(this->should_broadcast_), YESNO(this->should_listen_));
 }
 
-bool UDPComponent::send_packet(const uint8_t *data, size_t size) {
+void UDPComponent::send_packet(const uint8_t *data, size_t size) {
   if (this->is_failed())
-    return false;  // a send socket may be missing
-  bool sent = true;
+    return;  // a send socket may be missing
   for (const auto &entry : this->sockaddrs_) {
 #ifdef USE_UDP_IPV6_SEND
     const bool v6 = entry.sa.sa_family == AF_INET6;
@@ -269,23 +256,11 @@ bool UDPComponent::send_packet(const uint8_t *data, size_t size) {
     socket::UDPSendSocket *sock = this->broadcast_socket_.get();
     socklen_t sockaddr_size = sizeof(sockaddr_in);
 #endif
-    if (sock == nullptr) {
-      ESP_LOGW(TAG, "Broadcast socket not initialized");
-      return false;
-    }
     auto result = sock->sendto(data, size, 0, &entry.sa, sockaddr_size);
     if (result < 0) {
-      // lwIP refuses a packet with ENOMEM while the destination's ARP lookup is pending and its queue is full;
-      // the packet can be sent again later
-      if (errno == ENOMEM) {
-        ESP_LOGV(TAG, "sendto() out of memory");
-      } else {
-        ESP_LOGW(TAG, "sendto() error %d", errno);
-      }
-      sent = false;
+      ESP_LOGW(TAG, "sendto() error %d", errno);
     }
   }
-  return sent;
 }
 }  // namespace esphome::udp
 

esphome/components/udp/udp_component.h

@@ -32,14 +32,11 @@ class UDPComponent final : public Component {
   void set_ipv4_send(bool ipv4_send) { this->ipv4_send_ = ipv4_send; }
 #endif
   template<typename F> void add_listener(F &&listener) { this->packet_listeners_.add(std::forward<F>(listener)); }
-  /// The sender of the packet being passed to the listeners; valid only during a listener call.
-  const sockaddr *get_rx_source() const { return this->rx_source_; }
   void setup() override;
   void loop() override;
   void dump_config() override;
-  /// Returns false if the packet could not be sent to every destination.
-  bool send_packet(const uint8_t *data, size_t size);
-  bool send_packet(const std::vector<uint8_t> &buf) { return this->send_packet(buf.data(), buf.size()); }
+  void send_packet(const uint8_t *data, size_t size);
+  void send_packet(const std::vector<uint8_t> &buf) { this->send_packet(buf.data(), buf.size()); }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; };
 
  protected:
@@ -56,7 +53,7 @@ class UDPComponent final : public Component {
   bool network_poll_();
   void set_poll_warning_(PollStep step, const LogString *what);
 
-  LazyCallbackManager<void(std::span<const uint8_t>)> packet_listeners_{};
+  CallbackManager<void(std::span<const uint8_t>)> packet_listeners_{};
   std::unique_ptr<socket::UDPSendSocket> broadcast_socket_ = nullptr;
   std::unique_ptr<socket::UDPSocket> listen_socket_ = nullptr;
 #ifdef USE_UDP_IPV6_SEND
@@ -65,7 +62,6 @@ class UDPComponent final : public Component {
   FixedVector<SockaddrEntry> sockaddrs_{};
   const char *const *addresses_{nullptr};
   const char *listen_address_{nullptr};
-  const sockaddr *rx_source_{nullptr};
 #ifdef USE_SOCKET_IPV6
   uint32_t mcast_ifindex_{0};
 #endif

esphome/core/defines.h

@@ -75,8 +75,6 @@
 #define DFROBOT_SEN0465_COMPENSATION_RANGES 3
 #define USE_DISPLAY
 #define DISPLAY_PAGE_CHANGE_CALLBACK_COUNT 1
-#define ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT 1
-#define ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT 1
 #define USE_EMONTX_VERSION
 #define USE_EMONTX_VERSION_TEXT_SENSOR
 #define USE_ENTITY_DEVICE_CLASS
@@ -268,12 +266,6 @@
 #define USE_OTA_STATE_LISTENER
 #define USE_OUTPUT
 #define USE_OUTPUT_FLOAT_POWER_SCALING
-#define PACKET_INTERFACE_ADDRESSING_PORT_COUNT 2
-#define USE_PACKET_INTERFACE_BASIC_ADDRESSING
-#define USE_PACKET_INTERFACE_BASIC_FRAGMENTATION
-#define USE_PACKET_INTERFACE_BASIC_SESSION
-#define USE_PACKET_INTERFACE_HDLC
-#define USE_PACKET_INTERFACE_XXTEA
 #define USE_PCA9554_PCAL
 #define USE_POWER_SUPPLY
 // Only defined by key-lookup preference backends; the slot-based platforms

esphome/core/hash_base.h

@@ -29,14 +29,12 @@ class HashBase {
   void get_hex(char *output) { format_hex_to(output, this->get_size() * 2 + 1, this->digest_, this->get_size()); }
 
   /// Compare the hash against a provided byte-encoded hash
-  bool equals_bytes(const uint8_t *expected) { return constant_time_equals(this->digest_, expected, this->get_size()); }
+  bool equals_bytes(const uint8_t *expected) { return memcmp(this->digest_, expected, this->get_size()) == 0; }
 
-  /// Compare the hash against a provided hex-encoded hash of get_size() * 2 characters, which need not be
-  /// null-terminated
+  /// Compare the hash against a provided hex-encoded hash
   bool equals_hex(const char *expected) {
     uint8_t parsed[32];  // Fixed size for max hash (SHA256 = 32 bytes)
-    const size_t size = this->get_size();
-    if (parse_hex(expected, size * 2, parsed, size) != size * 2) {
+    if (!parse_hex(expected, parsed, this->get_size())) {
       return false;
     }
     return this->equals_bytes(parsed);

esphome/core/helpers.h

@@ -1112,16 +1112,6 @@ template<typename T> constexpr T convert_little_endian(T val) {
 #endif
 }
 
-/// Compare len bytes of a and b in a time that does not depend on where they first differ.
-/// Use this for digests, passwords and tokens, where memcmp's early exit leaks how many bytes matched.
-inline bool constant_time_equals(const uint8_t *a, const uint8_t *b, size_t len) {
-  volatile uint8_t diff = 0;
-  for (size_t i = 0; i < len; i++) {
-    diff = diff | (a[i] ^ b[i]);
-  }
-  return diff == 0;
-}
-
 ///@}
 
 /// @name Strings

script/build_helpers.py

@@ -188,8 +188,6 @@ def load_component_yaml_configs(components: list[str], tests_dir: Path) -> dict:
 
     The ``esphome:`` key is special: its sub-keys are merged into the
     existing esphome config (e.g. to add ``areas:`` or ``devices:``).
-    A list, such as the entries of a platform component, is extended, so
-    several directories can each add their own entries to one key.
     Keys already present in the base config (e.g. ``host:``, ``logger:``)
     are protected by ``setdefault`` in the caller.
 
@@ -215,9 +213,6 @@ def load_component_yaml_configs(components: list[str], tests_dir: Path) -> dict:
                     for sub_key, sub_value in value.items():
                         esphome_extra.setdefault(sub_key, sub_value)
                     continue
-                if isinstance(value, list) and isinstance(merged.get(key), list):
-                    merged[key] = merged[key] + value
-                    continue
                 merged.setdefault(key, value)
     return merged
 

tests/component_tests/mipi_spi/test_init.py

@@ -93,6 +93,16 @@ def run_schema_validation(config: ConfigType) -> None:
             r"value must be a power of two for dictionary value @ data\['draw_rounding'\]",
             id="invalid_draw_rounding",
         ),
+        pytest.param(
+            {
+                "model": "custom",
+                "dc_pin": 18,
+                "dimensions": {"width": 320, "height": 240},
+                "init_sequence": [[0xE0] + [0x00] * 129],
+            },
+            r"at most 128 data bytes",
+            id="init_command_too_long",
+        ),
     ],
 )
 def test_basic_configuration_errors(
@@ -606,3 +616,19 @@ def test_identical_init_sequences_share_one_table(
     assert first is not None and second is not None
     assert first.group(1) == second.group(1)
     assert main_cpp.count("mipi_spi_init_sequence[] PROGMEM") == 1
+
+
+def test_init_command_at_buffer_limit(set_core_config: SetCoreConfigCallable) -> None:
+    """A command with exactly 128 data bytes fits the C++ copy buffer."""
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+    run_schema_validation(
+        {
+            "model": "custom",
+            "dc_pin": 18,
+            "dimensions": {"width": 320, "height": 240},
+            "init_sequence": [[0xE0] + [0x00] * 128],
+        }
+    )

tests/components/core/test_constant_time_equals.cpp

@@ -1,39 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <cstdint>
-
-#include "esphome/core/helpers.h"
-
-namespace esphome {
-
-TEST(ConstantTimeEquals, EqualBuffers) {
-  const uint8_t a[] = {0x00, 0x01, 0x7F, 0x80, 0xFF};
-  const uint8_t b[] = {0x00, 0x01, 0x7F, 0x80, 0xFF};
-  EXPECT_TRUE(constant_time_equals(a, b, sizeof(a)));
-}
-
-TEST(ConstantTimeEquals, FirstByteDiffers) {
-  const uint8_t a[] = {0x00, 0x01, 0x02, 0x03};
-  const uint8_t b[] = {0x10, 0x01, 0x02, 0x03};
-  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
-}
-
-TEST(ConstantTimeEquals, LastByteDiffers) {
-  const uint8_t a[] = {0x00, 0x01, 0x02, 0x03};
-  const uint8_t b[] = {0x00, 0x01, 0x02, 0x13};
-  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
-}
-
-TEST(ConstantTimeEquals, SingleBitDifference) {
-  const uint8_t a[] = {0xAA, 0xAA};
-  const uint8_t b[] = {0xAA, 0xAB};
-  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
-}
-
-TEST(ConstantTimeEquals, ZeroLengthIsEqual) {
-  const uint8_t a[] = {0x01};
-  const uint8_t b[] = {0x02};
-  EXPECT_TRUE(constant_time_equals(a, b, 0));
-}
-
-}  // namespace esphome

tests/components/core/test_hash_base_equals.cpp

@@ -1,54 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <cstring>
-
-#include "esphome/core/hash_base.h"
-
-namespace esphome {
-
-// A four byte "hash" whose digest is set directly, so the compare helpers can be tested on their own
-class FixedHash : public HashBase {
- public:
-  void init() override {}
-  void add(const uint8_t *data, size_t len) override {}
-  void calculate() override {}
-  size_t get_size() const override { return 4; }
-  void set_digest(const uint8_t *digest) { memcpy(this->digest_, digest, 4); }
-};
-
-static const uint8_t DIGEST[] = {0xDE, 0xAD, 0xBE, 0xEF};
-
-TEST(HashBaseEquals, BytesMatch) {
-  FixedHash hash;
-  hash.set_digest(DIGEST);
-  EXPECT_TRUE(hash.equals_bytes(DIGEST));
-  const uint8_t other[] = {0xDE, 0xAD, 0xBE, 0xEE};
-  EXPECT_FALSE(hash.equals_bytes(other));
-}
-
-TEST(HashBaseEquals, HexMatchEitherCase) {
-  FixedHash hash;
-  hash.set_digest(DIGEST);
-  EXPECT_TRUE(hash.equals_hex("deadbeef"));
-  EXPECT_TRUE(hash.equals_hex("DEADBEEF"));
-  EXPECT_FALSE(hash.equals_hex("deadbeee"));
-}
-
-TEST(HashBaseEquals, HexWithoutTerminatorOnlyReadsDigestLength) {
-  FixedHash hash;
-  hash.set_digest(DIGEST);
-  // The expected digest sits in a larger buffer with no terminator after it, as in the OTA auth buffer
-  const char buffer[] = {'d', 'e', 'a', 'd', 'b', 'e', 'e', 'f', 'z', 'z', 'z', 'z'};
-  EXPECT_TRUE(hash.equals_hex(buffer));
-}
-
-TEST(HashBaseEquals, ShortOrInvalidHexRejected) {
-  FixedHash hash;
-  hash.set_digest(DIGEST);
-  EXPECT_FALSE(hash.equals_hex("deadbee"));
-  EXPECT_FALSE(hash.equals_hex(""));
-  EXPECT_FALSE(hash.equals_hex("deadbeeg"));
-}
-
-}  // namespace esphome

tests/components/display/test_init_sequence.cpp

@@ -0,0 +1,82 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "esphome/components/display/init_sequence.h"
+
+namespace esphome::display::testing {
+
+TEST(InitSequenceReader, WalksCommandsAndDelays) {
+  static const uint8_t SEQ[] = {0x11, 0x00, 120, 0xFF, 0x3A, 0x01, 0x55, 0x2A, 0x02, 0x00, 0xEF};
+  InitSequenceReader reader(SEQ, sizeof(SEQ));
+  InitSequenceEntry entry{};
+
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(entry.value, 0x11);
+  EXPECT_EQ(entry.count, 0);
+
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_DELAY);
+  EXPECT_EQ(entry.value, 120);
+
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(entry.value, 0x3A);
+  ASSERT_EQ(entry.count, 1);
+  EXPECT_EQ(entry.args, &SEQ[6]);
+
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(entry.value, 0x2A);
+  ASSERT_EQ(entry.count, 2);
+  EXPECT_EQ(entry.args[0], 0x00);
+  EXPECT_EQ(entry.args[1], 0xEF);
+
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+}
+
+TEST(InitSequenceReader, EmptySequenceEnds) {
+  InitSequenceReader reader(nullptr, 0);
+  InitSequenceEntry entry{};
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+}
+
+// A count above 127 is a real length, not a flag bit.
+TEST(InitSequenceReader, HonoursFullCount) {
+  uint8_t seq[2 + 253 + 2] = {0x32, 253};
+  seq[2 + 253] = 0x29;
+  InitSequenceReader reader(seq, sizeof(seq));
+  InitSequenceEntry entry{};
+
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(entry.value, 0x32);
+  EXPECT_EQ(entry.count, 253);
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(entry.value, 0x29);
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+}
+
+TEST(InitSequenceReader, TruncatedHeaderIsMalformed) {
+  static const uint8_t SEQ[] = {0x11, 0x00, 0x29};
+  InitSequenceReader reader(SEQ, sizeof(SEQ));
+  InitSequenceEntry entry{};
+  ASSERT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_COMMAND);
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_MALFORMED);
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+}
+
+TEST(InitSequenceReader, ShortArgsAreMalformed) {
+  static const uint8_t SEQ[] = {0x2A, 0x04, 0x00, 0x00, 0x00};
+  InitSequenceReader reader(SEQ, sizeof(SEQ));
+  InitSequenceEntry entry{};
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_MALFORMED);
+  EXPECT_EQ(reader.next(entry), INIT_SEQUENCE_STEP_END);
+}
+
+TEST(InitSequenceReader, CountOverMaxIsMalformed) {
+  static const uint8_t SEQ[] = {10, 0xFF, 0x2A, 0x02, 0x00, 0xEF};
+  InitSequenceReader reader(SEQ, sizeof(SEQ));
+  InitSequenceEntry entry{};
+  ASSERT_EQ(reader.next(entry, 1), INIT_SEQUENCE_STEP_DELAY);
+  EXPECT_EQ(reader.next(entry, 1), INIT_SEQUENCE_STEP_MALFORMED);
+}
+
+}  // namespace esphome::display::testing

tests/components/entity_transport/__init__.py

@@ -1,19 +0,0 @@
-import esphome.codegen as cg
-from esphome.core import CORE
-from esphome.types import ConfigType
-from tests.testing_helpers import ComponentManifestOverride
-
-
-def override_manifest(manifest: ComponentManifestOverride) -> None:
-    async def to_code_testing(config: ConfigType) -> None:
-        cg.add_define("ENTITY_TRANSPORT_REMOTE_BINARY_SENSOR_COUNT", 2)
-        cg.add_define("ENTITY_TRANSPORT_REMOTE_SENSOR_COUNT", 2)
-        cg.add_define("USE_PACKET_INTERFACE_BASIC_SESSION")
-        # No entity platforms are configured, so count the test's own entities to emit USE_SENSOR and friends
-        CORE.platform_counts["sensor"] += 2
-        CORE.platform_counts["binary_sensor"] += 2
-
-    manifest.to_code = to_code_testing
-    # A multi_conf component gets an empty list in the test build, so to_code would not run
-    manifest.multi_conf = False
-    manifest.dependencies = manifest.dependencies + ["sensor", "binary_sensor"]

tests/components/entity_transport/common.yaml

@@ -1,33 +0,0 @@
-packet_interface:
-  - platform: uart
-    id: entity_transport_link
-    reliability:
-
-sensor:
-  - platform: template
-    id: entity_transport_sensor
-    lambda: return 1.0;
-  - platform: entity_transport
-    provider: remote-device
-    remote_id: entity_transport_sensor
-    name: Remote sensor
-
-binary_sensor:
-  - platform: template
-    id: entity_transport_binary_sensor
-    lambda: return true;
-  - platform: entity_transport
-    id: remote_binary_sensor
-    provider: remote-device
-    remote_id: door
-    name: Remote binary sensor
-
-entity_transport:
-  - packet_interface: entity_transport_link
-    update_interval: 60s
-    timeout: 3min
-    sensors:
-      - entity_transport_sensor
-    binary_sensors:
-      - id: entity_transport_binary_sensor
-        broadcast_id: door