Update the patched UART component to ESPHome 2026.11.0
ESPHome 2026.11's tuya component calls uart.new_uart_component(), which the 2026.10.2 copy didn't have, so the build failed. Copy the UART component from 2026.11.0, reapply the PA13/PA14 patch, regenerate the patch file and point the refs at v1.0.6. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
bcc6b3a42b
commit
1457e25d98
39 files changed
+907
-304
No files matched your search
@@ -0,0 +1,36 @@
|
||||
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)
|
||||
@@ -0,0 +1,82 @@
|
||||
#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
|
||||
@@ -0,0 +1,36 @@
|
||||
#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
|
||||
Reference in new issue
Block a user