diff --git a/CLAUDE.md b/CLAUDE.md index 7f58968..0bc81df 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -7,7 +7,7 @@ ESPHome firmware for a Moes Wake Up Light II (Tuya PID `ya39qahrcdhvxowz`), runn - `wake-up-light-ii.yaml`: main config. - `alarm_block.yaml`: controls for one alarm, included 4 times. - `alarm_day.yaml`: one weekday switch, included 7 times per alarm. -- `components/uart`: ESPHome 2026.10.2's UART component with `patches/wbr3-pa13-pa14-uart.patch` applied. Recheck it when ESPHome updates. +- `components/uart`: ESPHome 2026.11.0's UART component with `patches/wbr3-pa13-pa14-uart.patch` applied. Recheck it when ESPHome updates. - `server-example.yaml`: the short YAML that goes on an ESPHome server. - `secrets.yaml`: local only, ignored by git. Needs `wifi_ssid`, `wifi_password`, `ap_password`, `api_encryption_key`. diff --git a/README.md b/README.md index 0fdb44e..fe9d0e5 100644 --- a/README.md +++ b/README.md @@ -134,7 +134,7 @@ The exact-PID `tuya-local` profile maps DP132 color strings to white/red/orange/ ## Using this from an ESPHome server -Copy `server-example.yaml` to the server and add `wifi_ssid`, `wifi_password`, `ap_password` and `api_encryption_key` to its `secrets.yaml`. The patched UART in `components/uart` loads automatically, so the server's ESPHome install needs no patch. It's a copy from ESPHome 2026.10.2, so recheck it when updating ESPHome. To release a change, update `ref` in `wake-up-light-ii.yaml`, tag that commit, then update `ref` in the server's YAML. +Copy `server-example.yaml` to the server and add `wifi_ssid`, `wifi_password`, `ap_password` and `api_encryption_key` to its `secrets.yaml`. The patched UART in `components/uart` loads automatically, so the server's ESPHome install needs no patch. It's a copy from ESPHome 2026.11.0, so recheck it when updating ESPHome. To release a change, update `ref` in `wake-up-light-ii.yaml`, tag that commit, then update `ref` in the server's YAML. ## Corrections from Tuya's data model @@ -225,7 +225,7 @@ Patch files in this repository: - [`patches/wbr3-pa13-pa14-uart.patch`](patches/wbr3-pa13-pa14-uart.patch) - [`patches/apply_uart_patch.py`](patches/apply_uart_patch.py) -The patch file is written against the 2026.9-era ESPHome source layout. The helper script fails instead of patching blindly if the source shape changes. +The patch file is written against ESPHome 2026.11.0. The helper script fails instead of patching blindly if the source shape changes. ### Apply the patch to a pip/Conda ESPHome install diff --git a/components/uart/__init__.py b/components/uart/__init__.py index 25fbfb7..b811131 100644 --- a/components/uart/__init__.py +++ b/components/uart/__init__.py @@ -1,6 +1,9 @@ +from collections.abc import Coroutine +from dataclasses import dataclass, field from logging import getLogger import math import re +from typing import Any from esphome import automation, pins import esphome.codegen as cg @@ -54,6 +57,7 @@ from esphome.const import ( ) from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority import esphome.final_validate as fv +from esphome.types import ConfigType from esphome.yaml_util import make_data_base _LOGGER = getLogger(__name__) @@ -117,13 +121,18 @@ HOST_BAUD_RATES = [ ] UARTDevice = uart_ns.class_("UARTDevice") -UARTWriteAction = uart_ns.class_("UARTWriteAction", automation.Action) UARTDebugger = uart_ns.class_("UARTDebugger", cg.Component, automation.Action) UARTDummyReceiver = uart_ns.class_("UARTDummyReceiver", cg.Component) MULTI_CONF = True MULTI_CONF_NO_DEFAULT = True +def is_host_uart(uart_id: ID, full_config: ConfigType) -> bool: + return CORE.is_host and any( + conf[CONF_ID] == uart_id for conf in full_config.get(DOMAIN) or [] + ) + + def validate_raw_data(value): if isinstance(value, str): return value.encode("utf-8") @@ -136,6 +145,10 @@ def validate_raw_data(value): ) +# Lengths are stored as uint16_t; reject longer payloads at validation. +validate_raw_payload = cv.All(validate_raw_data, cv.Length(max=65535)) + + def validate_rx_pin(value): value = pins.internal_gpio_input_pin_schema(value) if CORE.is_esp8266 and value[CONF_NUMBER] >= 16: @@ -187,11 +200,9 @@ def _uart_declare_type(value): UARTParityOptions = uart_ns.enum("UARTParityOptions") -UART_PARITY_OPTIONS = { - "NONE": UARTParityOptions.UART_CONFIG_PARITY_NONE, - "EVEN": UARTParityOptions.UART_CONFIG_PARITY_EVEN, - "ODD": UARTParityOptions.UART_CONFIG_PARITY_ODD, -} +UART_PARITY_OPTIONS = UARTParityOptions.options( + "NONE", "EVEN", "ODD", prefix="UART_CONFIG_PARITY_" +) CONF_FLUSH_TIMEOUT = "flush_timeout" CONF_RX_FULL_THRESHOLD = "rx_full_threshold" @@ -199,13 +210,9 @@ CONF_RX_TIMEOUT = "rx_timeout" CONF_CLOCK_SOURCE = "clock_source" UARTClockSource = cg.global_ns.enum("uart_sclk_t") -UART_CLOCK_SOURCES = { - "DEFAULT": UARTClockSource.UART_SCLK_DEFAULT, - "APB": UARTClockSource.UART_SCLK_APB, - "XTAL": UARTClockSource.UART_SCLK_XTAL, - "RTC": UARTClockSource.UART_SCLK_RTC, - "REF_TICK": UARTClockSource.UART_SCLK_REF_TICK, -} +UART_CLOCK_SOURCES = UARTClockSource.options( + "DEFAULT", "APB", "XTAL", "RTC", "REF_TICK", prefix="UART_SCLK_" +) # Keep in sync with SOC_UART_SUPPORT_* in ESP-IDF's per-variant soc_caps.h. UART_CLOCK_SOURCES_BY_VARIANT = { @@ -225,11 +232,7 @@ UART_CLOCK_SOURCES_BY_VARIANT = { } UARTDirection = uart_ns.enum("UARTDirection") -UART_DIRECTIONS = { - "RX": UARTDirection.UART_DIRECTION_RX, - "TX": UARTDirection.UART_DIRECTION_TX, - "BOTH": UARTDirection.UART_DIRECTION_BOTH, -} +UART_DIRECTIONS = UARTDirection.options("RX", "TX", "BOTH", prefix="UART_DIRECTION_") # The reason for having CONF_BYTES at 150 by default: # @@ -274,7 +277,9 @@ DEBUG_SCHEMA = cv.Schema( cv.Optional( CONF_TIMEOUT, default=AFTER_DEFAULTS[CONF_TIMEOUT] ): cv.positive_time_period_milliseconds, - cv.Optional(CONF_DELIMITER): cv.templatable(validate_raw_data), + cv.Optional(CONF_DELIMITER): cv.All( + validate_raw_data, cv.Length(max=255) + ), } ), cv.Optional( @@ -345,12 +350,11 @@ async def debug_to_code(config, parent): after = config[CONF_AFTER] cg.add(trigger.set_after_bytes(after[CONF_BYTES])) cg.add(trigger.set_after_timeout(after[CONF_TIMEOUT])) - if CONF_DELIMITER in after: - data = after[CONF_DELIMITER] - if isinstance(data, bytes): - data = list(data) - for byte in after[CONF_DELIMITER]: - cg.add(trigger.add_delimiter_byte(byte)) + if delimiter := after.get(CONF_DELIMITER): + table = cg.shared_progmem_array( + "uart_debug_delimiter", cg.uint8, [int(b) for b in delimiter] + ) + cg.add(trigger.set_after_delimiter(table, len(delimiter))) if config[CONF_DUMMY_RECEIVER]: dummy = cg.new_Pvariable(config[CONF_DUMMY_RECEIVER_ID], parent) await cg.register_component(dummy, {}) @@ -366,17 +370,10 @@ async def to_code(config): cg.add(var.set_baud_rate(config[CONF_BAUD_RATE])) - if CONF_TX_PIN in config: - tx_pin = await cg.gpio_pin_expression(config[CONF_TX_PIN]) - cg.add(var.set_tx_pin(tx_pin)) - if CONF_RX_PIN in config: - rx_pin = await cg.gpio_pin_expression(config[CONF_RX_PIN]) - cg.add(var.set_rx_pin(rx_pin)) - if CONF_FLOW_CONTROL_PIN in config: - flow_control_pin = await cg.gpio_pin_expression(config[CONF_FLOW_CONTROL_PIN]) - cg.add(var.set_flow_control_pin(flow_control_pin)) - if CONF_PORT in config: - cg.add(var.set_name(config[CONF_PORT])) + await cg.add_pin(var.set_tx_pin, config.get(CONF_TX_PIN)) + await cg.add_pin(var.set_rx_pin, config.get(CONF_RX_PIN)) + await cg.add_pin(var.set_flow_control_pin, config.get(CONF_FLOW_CONTROL_PIN)) + cg.add_optional(var.set_name, config.get(CONF_PORT)) cg.add(var.set_rx_buffer_size(config[CONF_RX_BUFFER_SIZE])) if CORE.is_esp32: if CONF_RX_FULL_THRESHOLD not in config: @@ -393,10 +390,8 @@ async def to_code(config): ) cg.add(var.set_rx_full_threshold(config[CONF_RX_FULL_THRESHOLD])) cg.add(var.set_rx_timeout(config[CONF_RX_TIMEOUT])) - if CONF_FLUSH_TIMEOUT in config: - cg.add(var.set_flush_timeout(config[CONF_FLUSH_TIMEOUT])) - if (tx_buffer_size := config.get(CONF_TX_BUFFER_SIZE)) is not None: - cg.add(var.set_tx_buffer_size(tx_buffer_size)) + cg.add_optional(var.set_flush_timeout, config.get(CONF_FLUSH_TIMEOUT)) + cg.add_optional(var.set_tx_buffer_size, config.get(CONF_TX_BUFFER_SIZE)) # The member already defaults to UART_SCLK_DEFAULT, so only emit a real choice if (clock_source := config.get(CONF_CLOCK_SOURCE, "DEFAULT")) != "DEFAULT": cg.add(var.set_clock_source(UART_CLOCK_SOURCES[clock_source])) @@ -444,6 +439,34 @@ UART_DEVICE_SCHEMA = cv.Schema( KEY_UART_DEVICES = "uart_devices" +@dataclass +class UARTData: + # UARTs whose received bytes do not keep the timing of a serial line. + unclocked: list[ID] = field(default_factory=list) + + +def _get_data() -> UARTData: + if DOMAIN not in CORE.data: + CORE.data[DOMAIN] = UARTData() + return CORE.data[DOMAIN] + + +def mark_unclocked(uart_id: ID) -> ID: + """Record that the bytes of uart_id do not arrive with the timing of a serial line, e.g. over TCP or USB. + + A gap between them says nothing about where a frame ends. Use it on the UART's declared id, + cv.All(cv.declare_id(MyUart), uart.mark_unclocked), so that every to_code sees it. + """ + _get_data().unclocked.append(uart_id) + return uart_id + + +def is_unclocked(uart_id: ID) -> bool: + """Return True if uart_id was passed to mark_unclocked().""" + # By name: a generated id is named only after the schemas ran. + return any(str(uart) == str(uart_id) for uart in _get_data().unclocked) + + def final_validate_device_schema( name: str, *, @@ -533,43 +556,57 @@ def final_validate_device_schema( ) +def subtree_references_uart( + node: object, uart_id: str, conf_key: str = CONF_UART_ID +) -> bool: + """Return True if any dict in the subtree has a conf_key entry naming this bus. + + For the final validation of a component that needs a UART for itself. Bare + `id:` references (a uart.write action) and lambdas are not found. + """ + if isinstance(node, dict): + return any( + (key == conf_key and str(value) == uart_id) + or subtree_references_uart(value, uart_id, conf_key) + for key, value in node.items() + ) + if isinstance(node, list): + return any(subtree_references_uart(item, uart_id, conf_key) for item in node) + return False + + async def register_uart_device(var, config): """Register a UART device, setting up all the internal values. This is a coroutine, you need to await it with an 'await' expression! """ - parent = await cg.get_variable(config[CONF_UART_ID]) - cg.add(var.set_uart_parent(parent)) + await cg.add_variable(var.set_uart_parent, config[CONF_UART_ID]) -@automation.register_action( +def new_uart_component( + config: ConfigType, *args: Any +) -> Coroutine[Any, Any, cg.MockObj]: + """Create a component on a UART bus: construct, register, attach to the bus. + + Extra args go to the constructor. + """ + return cg.new_bus_component(register_uart_device, config, *args) + + +automation.register_apply_action( "uart.write", - UARTWriteAction, cv.maybe_simple_value( { cv.GenerateID(): cv.use_id(UARTComponent), - cv.Required(CONF_DATA): cv.templatable(validate_raw_data), + cv.Required(CONF_DATA): cv.templatable(validate_raw_payload), }, key=CONF_DATA, ), - synchronous=True, + # A constant stays in flash: write_array_progmem copies it out in chunks on ESP8266 + automation.ApplyBytes( + CONF_DATA, "write_array({})", progmem_target="write_array_progmem({})" + ), ) -async def uart_write_to_code(config, action_id, template_arg, args): - var = cg.new_Pvariable(action_id, template_arg) - await cg.register_parented(var, config[CONF_ID]) - data = config[CONF_DATA] - if isinstance(data, bytes): - data = list(data) - - if cg.is_template(data): - templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8)) - cg.add(var.set_data_template(templ)) - else: - # Generate static array in flash to avoid RAM copy - arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8) - arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*data)) - cg.add(var.set_data_static(arr, len(data))) - return var @coroutine_with_priority(CoroPriority.FINAL) diff --git a/components/uart/automation.h b/components/uart/automation.h deleted file mode 100644 index e5a9fa7..0000000 --- a/components/uart/automation.h +++ /dev/null @@ -1,43 +0,0 @@ -#pragma once - -#include "uart.h" -#include "esphome/core/automation.h" - -#include - -namespace esphome::uart { - -template class UARTWriteAction final : public Action, public Parented { - public: - void set_data_template(std::vector (*func)(Ts...)) { - // Stateless lambdas (generated by ESPHome) implicitly convert to function pointers - this->code_.func = func; - this->len_ = -1; // Sentinel value indicates template mode - } - - // Store pointer to static data in flash (no RAM copy) - void set_data_static(const uint8_t *data, size_t len) { - this->code_.data = data; - this->len_ = len; // Length >= 0 indicates static mode - } - - void play(const Ts &...x) override { - if (this->len_ >= 0) { - // Static mode: use pointer and length - this->parent_->write_array(this->code_.data, static_cast(this->len_)); - } else { - // Template mode: call function - auto val = this->code_.func(x...); - this->parent_->write_array(val); - } - } - - protected: - ssize_t len_{-1}; // -1 = template mode, >=0 = static mode with length - union Code { - std::vector (*func)(Ts...); // Function pointer (stateless lambdas) - const uint8_t *data; // Pointer to static data in flash - } code_; -}; - -} // namespace esphome::uart diff --git a/components/uart/binary_sensor/__init__.py b/components/uart/binary_sensor/__init__.py new file mode 100644 index 0000000..f5f2524 --- /dev/null +++ b/components/uart/binary_sensor/__init__.py @@ -0,0 +1,100 @@ +from esphome import automation +import esphome.codegen as cg +from esphome.components import binary_sensor, uart +import esphome.config_validation as cv +from esphome.const import CONF_DATA, CONF_UART_ID +from esphome.core import CORE, ID +import esphome.final_validate as fv +from esphome.types import ConfigType + +from .. import uart_ns, validate_raw_data + +DEPENDENCIES = ["uart"] +DOMAIN = "uart_binary_sensor" + +CONF_HUB_ID = "hub_id" + +UARTBinarySensorHub = uart_ns.class_( + "UARTBinarySensorHub", uart.UARTDevice, cg.Component +) + +# Every sensor on a bus is one matcher of that bus's hub; the define is the largest hub +_request_matcher_slot = cg.slot_counter("UART_BINARY_SENSOR_COUNT") + +CONFIG_SCHEMA = ( + # Initially off, so the first sequence after boot is an OFF to ON edge for on_press + binary_sensor.binary_sensor_schema(binary_sensor.BinarySensorInitiallyOff) + .extend( + { + cv.GenerateID(CONF_HUB_ID): cv.declare_id(UARTBinarySensorHub), + # An empty pattern would match every byte; the hub's buffer index is a byte + cv.Required(CONF_DATA): cv.All( + validate_raw_data, cv.Length(min=1, max=255) + ), + } + ) + .extend(uart.UART_DEVICE_SCHEMA) +) + + +_validate_bus = uart.final_validate_device_schema("uart binary_sensor", require_rx=True) + + +def _one_hub_per_bus(config: ConfigType) -> ConfigType: + """The first matching sensor takes the bytes and clears them, so a sequence that contains + another on the same bus would leave one of them dead; and the sensors of a bus share the hub + the first one creates, so only that one can name it and claim the bus's receive side.""" + data = bytes(config[CONF_DATA]) + first = True + for other in fv.platform_entries( + domain="binary_sensor", + platform="uart", + match={CONF_UART_ID: config[CONF_UART_ID]}, + ): + if other is config: + break # Every sensor before this one on the bus has been seen + first = False + other_data = bytes(other[CONF_DATA]) + if other_data in data or data in other_data: + raise cv.Invalid( + f"Another uart binary_sensor on '{config[CONF_UART_ID]}' has data this pattern " + "would match as well" + ) + if config[CONF_HUB_ID].is_manual: + raise cv.Invalid( + f"Set hub_id on the first uart binary_sensor of '{config[CONF_UART_ID]}'; " + "the others share its hub" + ) + if first: + _validate_bus(config) + return config + + +FINAL_VALIDATE_SCHEMA = _one_hub_per_bus + + +def _hubs() -> dict[ID, cg.MockObj]: + """The hub of each bus, keyed by the bus id.""" + return CORE.data.setdefault(DOMAIN, {}) + + +async def _hub_for(config: ConfigType) -> cg.MockObj: + """The one hub that reads the bus for every sensor on it, created by the first sensor.""" + hubs = _hubs() + if (hub := hubs.get(config[CONF_UART_ID])) is None: + hub = hubs[config[CONF_UART_ID]] = cg.new_Pvariable(config[CONF_HUB_ID]) + await cg.register_component(hub, config) + await uart.register_uart_device(hub, config) + return hub + + +async def to_code(config: ConfigType) -> None: + hub = await _hub_for(config) + var = await binary_sensor.new_binary_sensor(config) + data = config[CONF_DATA] + _request_matcher_slot(str(hub)) + cg.add( + hub.add_event_matcher( + var, automation.progmem_bytes("uart_binary_sensor_data", data), len(data) + ) + ) diff --git a/components/uart/binary_sensor/uart_binary_sensor.cpp b/components/uart/binary_sensor/uart_binary_sensor.cpp new file mode 100644 index 0000000..67158c8 --- /dev/null +++ b/components/uart/binary_sensor/uart_binary_sensor.cpp @@ -0,0 +1,47 @@ +#include "uart_binary_sensor.h" +#include "esphome/core/hal.h" +#include "esphome/core/log.h" + +namespace esphome::uart { + +ESPHOME_LOG_TAG(TAG, "uart.binary_sensor"); + +void UARTBinarySensorHub::dump_config() { + ESP_LOGCONFIG(TAG, "UART Binary Sensor:"); + for (const auto &matcher : this->matchers_) { + LOG_BINARY_SENSOR(" ", "Pattern", matcher.sensor); + } +} + +void UARTBinarySensorHub::loop() { + this->read_available([this](uint8_t byte) { + this->buffer_.push_overwrite(byte); + for (const auto &matcher : this->matchers_) { + // The byte just read has to be the pattern's last one before the rest is compared + if (progmem_read_byte(&matcher.data[matcher.data_len - 1]) != byte || !this->matches_(matcher)) { + continue; + } + // A momentary press, as the remote receiver binary sensors publish theirs + matcher.sensor->publish_state(true); + matcher.sensor->publish_state(false); + this->buffer_.clear(); + break; + } + }); +} + +// Whether the pattern, apart from its last byte, ends the buffer +bool UARTBinarySensorHub::matches_(const EventMatcher &matcher) const { + if (this->buffer_.size() < matcher.data_len) { + return false; + } + const size_t start = this->buffer_.size() - matcher.data_len; + for (size_t i = 0; i + 1 < matcher.data_len; i++) { + if (this->buffer_[start + i] != progmem_read_byte(&matcher.data[i])) { + return false; + } + } + return true; +} + +} // namespace esphome::uart diff --git a/components/uart/binary_sensor/uart_binary_sensor.h b/components/uart/binary_sensor/uart_binary_sensor.h new file mode 100644 index 0000000..71ccda9 --- /dev/null +++ b/components/uart/binary_sensor/uart_binary_sensor.h @@ -0,0 +1,37 @@ +#pragma once + +#include "esphome/components/binary_sensor/binary_sensor.h" +#include "esphome/components/uart/uart.h" +#include "esphome/core/defines.h" +#include "esphome/core/helpers.h" + +namespace esphome::uart { + +// One per bus: reads the bytes once and presses each sensor whose pattern ends the stream +class UARTBinarySensorHub : public UARTDevice, public Component { + public: + void setup() override { this->buffer_.init(this->max_len_); } + void loop() override; + void dump_config() override; + + // The pattern lives in flash; called once per sensor by the generated code + void add_event_matcher(binary_sensor::BinarySensor *sensor, const uint8_t *data, uint8_t data_len) { + this->matchers_.push_back({sensor, data, data_len}); + this->max_len_ = std::max(this->max_len_, data_len); + } + + protected: + struct EventMatcher { + binary_sensor::BinarySensor *sensor; + const uint8_t *data; + uint8_t data_len; + }; + + bool matches_(const EventMatcher &matcher) const; + + StaticVector matchers_; + FixedRingBuffer buffer_; + uint8_t max_len_{0}; +}; + +} // namespace esphome::uart diff --git a/components/uart/button/__init__.py b/components/uart/button/__init__.py index 95fe212..4fc285b 100644 --- a/components/uart/button/__init__.py +++ b/components/uart/button/__init__.py @@ -1,36 +1,29 @@ -import esphome.codegen as cg +from esphome import automation from esphome.components import button, uart import esphome.config_validation as cv -from esphome.const import CONF_DATA -from esphome.core import HexInt +from esphome.const import CONF_DATA, CONF_UART_ID +from esphome.types import ConfigType -from .. import uart_ns, validate_raw_data +from .. import validate_raw_payload CODEOWNERS = ["@ssieb"] DEPENDENCIES = ["uart"] -UARTButton = uart_ns.class_("UARTButton", button.Button, uart.UARTDevice, cg.Component) - - CONFIG_SCHEMA = ( - button.button_schema(UARTButton) + button.button_schema(button.ApplyButton) .extend( { - cv.Required(CONF_DATA): validate_raw_data, + cv.Required(CONF_DATA): validate_raw_payload, } ) .extend(uart.UART_DEVICE_SCHEMA) - .extend(cv.COMPONENT_SCHEMA) ) -async def to_code(config): - var = await button.new_button(config) - await cg.register_component(var, config) - await uart.register_uart_device(var, config) - +async def to_code(config: ConfigType) -> None: data = config[CONF_DATA] - if isinstance(data, bytes): - data = [HexInt(x) for x in data] - cg.add(var.set_data(cg.ArrayInitializer(*data))) + table = automation.progmem_bytes("uart_data", data) + await button.sub_buttons(config, parent=config[CONF_UART_ID]).create( + config, None, apply=f"write_array_progmem({table}, {len(data)})" + ) diff --git a/components/uart/button/uart_button.cpp b/components/uart/button/uart_button.cpp deleted file mode 100644 index 809ceaa..0000000 --- a/components/uart/button/uart_button.cpp +++ /dev/null @@ -1,15 +0,0 @@ -#include "uart_button.h" -#include "esphome/core/log.h" - -namespace esphome::uart { - -static const char *const TAG = "uart.button"; - -void UARTButton::press_action() { - ESP_LOGD(TAG, "'%s': Sending data", this->get_name().c_str()); - this->write_array(this->data_.data(), this->data_.size()); -} - -void UARTButton::dump_config() { LOG_BUTTON("", "UART Button", this); } - -} // namespace esphome::uart diff --git a/components/uart/button/uart_button.h b/components/uart/button/uart_button.h deleted file mode 100644 index 47f45d4..0000000 --- a/components/uart/button/uart_button.h +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include "esphome/core/component.h" -#include "esphome/components/uart/uart.h" -#include "esphome/components/button/button.h" - -#include - -namespace esphome::uart { - -class UARTButton final : public button::Button, public UARTDevice, public Component { - public: - void set_data(std::vector &&data) { this->data_ = std::move(data); } - void set_data(std::initializer_list data) { this->data_ = std::vector(data); } - - void dump_config() override; - - protected: - void press_action() override; - std::vector data_; -}; - -} // namespace esphome::uart diff --git a/components/uart/event/__init__.py b/components/uart/event/__init__.py index 64af318..beb32ab 100644 --- a/components/uart/event/__init__.py +++ b/components/uart/event/__init__.py @@ -1,8 +1,7 @@ import esphome.codegen as cg from esphome.components import event, uart import esphome.config_validation as cv -from esphome.const import CONF_EVENT_TYPES, CONF_ID -from esphome.core import ID +from esphome.const import CONF_EVENT_TYPES from esphome.types import ConfigType from .. import uart_ns @@ -12,9 +11,10 @@ CODEOWNERS = ["@eoasmxd"] DEPENDENCIES = ["uart"] UARTEvent = uart_ns.class_("UARTEvent", event.Event, uart.UARTDevice, cg.Component) +UARTEventMatcher = uart_ns.struct("UARTEventMatcher") -def validate_event_types(value) -> list[tuple[str, str | list[int]]]: +def validate_event_types(value) -> list[tuple[str, list[int]]]: if not isinstance(value, list): raise cv.Invalid("Event type must be a list of key-value mappings.") @@ -44,7 +44,7 @@ def validate_event_types(value) -> list[tuple[str, str | list[int]]]: try: # Try to validate as string match_data_str = cv.string_strict(match_data) - processed.append((event_name, match_data_str)) + processed.append((event_name, list(match_data_str.encode("utf-8")))) continue except cv.Invalid: pass # Not string either @@ -56,6 +56,10 @@ def validate_event_types(value) -> list[tuple[str, str | list[int]]]: if not processed: raise cv.Invalid("event_types must contain at least one event mapping.") + if len(processed) > 0xFFFF: + raise cv.Invalid("event_types can have at most 65535 entries.") + if any(len(data) > 0xFFFF for _, data in processed): + raise cv.Invalid("Event match data can be at most 65535 bytes.") return processed @@ -77,14 +81,23 @@ async def to_code(config: ConfigType) -> None: var = await event.new_event(config, event_types=event_names) await cg.register_component(var, config) await uart.register_uart_device(var, config) - for i, (event_name, match_data) in enumerate(config[CONF_EVENT_TYPES]): - if isinstance(match_data, str): - match_data = [ord(c) for c in match_data] - - match_data_var_id = ID( - f"match_data_{config[CONF_ID]}_{i}", is_declaration=True, type=cg.uint8 + matchers = [] + max_len = 0 + for event_name, match_data in config[CONF_EVENT_TYPES]: + match_data = [int(b) for b in match_data] + data = ( + cg.shared_progmem_array("uart_event_match", cg.uint8, match_data) + if match_data + else cg.nullptr ) - match_data_var = cg.static_const_array( - match_data_var_id, cg.ArrayInitializer(*match_data) + matchers.append( + cg.StructInitializer( + UARTEventMatcher, + ("event_name", event_name), + ("data", data), + ("data_len", len(match_data)), + ) ) - cg.add(var.add_event_matcher(event_name, match_data_var, len(match_data))) + max_len = max(max_len, len(match_data)) + table = cg.shared_progmem_array("uart_event_matchers", UARTEventMatcher, matchers) + cg.add(var.set_matchers(table, len(matchers), max_len)) diff --git a/components/uart/event/uart_event.cpp b/components/uart/event/uart_event.cpp index 02c5f2e..1257651 100644 --- a/components/uart/event/uart_event.cpp +++ b/components/uart/event/uart_event.cpp @@ -1,10 +1,10 @@ #include "uart_event.h" +#include "esphome/core/hal.h" #include "esphome/core/log.h" -#include namespace esphome::uart { -static const char *const TAG = "uart.event"; +ESPHOME_LOG_TAG(TAG, "uart.event"); void UARTEvent::setup() {} @@ -12,26 +12,23 @@ void UARTEvent::dump_config() { LOG_EVENT("", "UART Event", this); } void UARTEvent::loop() { this->read_data_(); } -void UARTEvent::add_event_matcher(const char *event_name, const uint8_t *match_data, size_t match_data_len) { - this->matchers_.push_back({event_name, match_data, match_data_len}); - if (match_data_len > this->max_matcher_len_) { - this->max_matcher_len_ = match_data_len; - } -} - void UARTEvent::read_data_() { - while (this->available()) { - uint8_t data; - this->read_byte(&data); + this->read_available([this](uint8_t data) { this->buffer_.push_back(data); bool match_found = false; - for (const auto &matcher : this->matchers_) { + for (uint16_t i = 0; i < this->matcher_count_; i++) { + const UARTEventMatcher &matcher = this->matchers_[i]; if (this->buffer_.size() < matcher.data_len) { continue; } - if (std::equal(matcher.data, matcher.data + matcher.data_len, this->buffer_.end() - matcher.data_len)) { + const uint8_t *tail = this->buffer_.data() + this->buffer_.size() - matcher.data_len; + size_t pos = 0; + // The pattern is in flash; ESP8266 only allows word loads there, so read it with progmem_read_byte + while (pos < matcher.data_len && progmem_read_byte(matcher.data + pos) == tail[pos]) + pos++; + if (pos == matcher.data_len) { this->trigger(matcher.event_name); this->buffer_.clear(); match_found = true; @@ -42,7 +39,7 @@ void UARTEvent::read_data_() { if (!match_found && this->max_matcher_len_ > 0 && this->buffer_.size() > this->max_matcher_len_) { this->buffer_.erase(this->buffer_.begin()); } - } + }); } } // namespace esphome::uart diff --git a/components/uart/event/uart_event.h b/components/uart/event/uart_event.h index 3960ffd..a676f60 100644 --- a/components/uart/event/uart_event.h +++ b/components/uart/event/uart_event.h @@ -1,31 +1,50 @@ #pragma once #include "esphome/core/component.h" +#include "esphome/core/defines.h" #include "esphome/components/event/event.h" #include "esphome/components/uart/uart.h" +#include #include namespace esphome::uart { +/// An event type and the byte pattern that fires it; `data` may point to PROGMEM. +struct UARTEventMatcher { + const char *event_name; + const uint8_t *data; + size_t data_len; +}; +// Codegen keeps the matchers in a flash table read with plain loads, which ESP8266 only allows for whole words. +static_assert(std::is_same_v, + "UARTEventMatcher fields must stay word sized"); +static_assert(std::is_same_v, + "UARTEventMatcher fields must stay word sized"); +static_assert(std::is_same_v, + "UARTEventMatcher fields must stay word sized"); +#ifdef USE_ESP8266 +static_assert(sizeof(UARTEventMatcher) == 3 * sizeof(uint32_t), "UARTEventMatcher is read from flash with word loads"); +#endif + class UARTEvent final : public event::Event, public UARTDevice, public Component { public: void setup() override; void loop() override; void dump_config() override; - void add_event_matcher(const char *event_name, const uint8_t *match_data, size_t match_data_len); + /// `matchers` is a codegen PROGMEM table that must outlive the component. + void set_matchers(const UARTEventMatcher *matchers, uint16_t count, uint16_t max_len) { + this->matchers_ = matchers; + this->matcher_count_ = count; + this->max_matcher_len_ = max_len; + } protected: - struct EventMatcher { - const char *event_name; - const uint8_t *data; - size_t data_len; - }; - void read_data_(); - std::vector matchers_; + const UARTEventMatcher *matchers_{nullptr}; std::vector buffer_; - size_t max_matcher_len_ = 0; + uint16_t matcher_count_{0}; + uint16_t max_matcher_len_{0}; }; } // namespace esphome::uart diff --git a/components/uart/packet_interface/__init__.py b/components/uart/packet_interface/__init__.py new file mode 100644 index 0000000..0564725 --- /dev/null +++ b/components/uart/packet_interface/__init__.py @@ -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) diff --git a/components/uart/packet_interface/uart_packet_interface.cpp b/components/uart/packet_interface/uart_packet_interface.cpp new file mode 100644 index 0000000..215212a --- /dev/null +++ b/components/uart/packet_interface/uart_packet_interface.cpp @@ -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 diff --git a/components/uart/packet_interface/uart_packet_interface.h b/components/uart/packet_interface/uart_packet_interface.h new file mode 100644 index 0000000..31a35e7 --- /dev/null +++ b/components/uart/packet_interface/uart_packet_interface.h @@ -0,0 +1,36 @@ +#pragma once + +#include + +#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 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 rx_buffer_; + size_t rx_length_{0}; + bool rx_started_{}; + bool rx_control_{}; +}; + +} // namespace esphome::uart diff --git a/components/uart/packet_transport/uart_transport.cpp b/components/uart/packet_transport/uart_transport.cpp index 6b8eae6..9ed73f7 100644 --- a/components/uart/packet_transport/uart_transport.cpp +++ b/components/uart/packet_transport/uart_transport.cpp @@ -4,7 +4,11 @@ namespace esphome::uart { -static const char *const TAG = "uart_transport"; +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(); @@ -78,4 +82,5 @@ void UARTTransport::send_packet(const std::vector &buf) const { this->parent_->write_byte(FLAG_BYTE); } +size_t UARTTransport::get_max_packet_size() { return MAX_PACKET_SIZE; } } // namespace esphome::uart diff --git a/components/uart/packet_transport/uart_transport.h b/components/uart/packet_transport/uart_transport.h index b1ce8ac..440ac58 100644 --- a/components/uart/packet_transport/uart_transport.h +++ b/components/uart/packet_transport/uart_transport.h @@ -16,9 +16,6 @@ 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: @@ -29,7 +26,7 @@ class UARTTransport final : public packet_transport::PacketTransport, public UAR void write_byte_(uint8_t byte) const; void send_packet(const std::vector &buf) const override; bool should_send() override { return true; }; - size_t get_max_packet_size() override { return MAX_PACKET_SIZE; } + size_t get_max_packet_size() override; std::vector receive_buffer_{}; bool rx_started_{}; bool rx_control_{}; diff --git a/components/uart/software_serial_tx_frame.h b/components/uart/software_serial_tx_frame.h new file mode 100644 index 0000000..14e065c --- /dev/null +++ b/components/uart/software_serial_tx_frame.h @@ -0,0 +1,39 @@ +#pragma once + +#include + +#include "esphome/core/helpers.h" + +namespace esphome::uart { + +/// One software serial TX byte as line levels, one bit per slot. +struct SoftwareSerialTxFrame { + /// The start bit at slot 0, then the frame, then a stop bit that ends the last run + uint32_t line; + /// Slot of the last 0; from the edge after it the line stays high through the stop bits + uint32_t high_from; + /// Slots right after an edge into a run of equal bits lasting at least `min_run_cycles`, where a pending + /// interrupt only delays bits that repeat the level + uint32_t unlock_at; +}; + +/// `frame` holds `num_bits` data and parity bits, LSB first. `unlock_at` stays 0 unless `find_unlocks`. +ESPHOME_ALWAYS_INLINE inline SoftwareSerialTxFrame software_serial_tx_frame(uint32_t frame, uint32_t num_bits, + uint32_t bit_time, uint32_t min_run_cycles, + bool find_unlocks) { + SoftwareSerialTxFrame tx; + tx.line = frame << 1 | (1u << (num_bits + 1)); + // Slot 0 is the start bit, always 0, so the argument is never 0 + tx.high_from = 31 - __builtin_clz(~tx.line & ((2u << num_bits) - 1)); + tx.unlock_at = 0; + if (find_unlocks) { + const uint32_t edges = tx.line ^ (tx.line << 1 | 1); // the idle line before the start bit is high + for (uint32_t pos = 0; pos <= tx.high_from; pos++) { + if (((edges >> pos) & 1) && (__builtin_ctz(edges >> (pos + 1)) + 1) * bit_time >= min_run_cycles) + tx.unlock_at |= 1u << pos; + } + } + return tx; +} + +} // namespace esphome::uart diff --git a/components/uart/switch/__init__.py b/components/uart/switch/__init__.py index 290bbed..4f0faea 100644 --- a/components/uart/switch/__init__.py +++ b/components/uart/switch/__init__.py @@ -1,10 +1,10 @@ +from esphome import automation import esphome.codegen as cg from esphome.components import switch, uart import esphome.config_validation as cv from esphome.const import CONF_DATA, CONF_SEND_EVERY -from esphome.core import HexInt -from .. import uart_ns, validate_raw_data +from .. import uart_ns, validate_raw_payload DEPENDENCIES = ["uart"] @@ -18,11 +18,11 @@ CONFIG_SCHEMA = ( .extend( { cv.Required(CONF_DATA): cv.Any( - validate_raw_data, + validate_raw_payload, cv.Schema( { - cv.Optional(CONF_TURN_OFF): validate_raw_data, - cv.Optional(CONF_TURN_ON): validate_raw_data, + cv.Optional(CONF_TURN_OFF): validate_raw_payload, + cv.Optional(CONF_TURN_ON): validate_raw_payload, } ), ), @@ -40,20 +40,15 @@ async def to_code(config): await uart.register_uart_device(var, config) data = config[CONF_DATA] - if isinstance(data, dict): - if data_on := data.get(CONF_TURN_ON): - if isinstance(data_on, bytes): - data_on = [HexInt(x) for x in data_on] - cg.add(var.set_data_on(cg.ArrayInitializer(*data_on))) - if data_off := data.get(CONF_TURN_OFF): - if isinstance(data_off, bytes): - data_off = [HexInt(x) for x in data_off] - cg.add(var.set_data_off(cg.ArrayInitializer(*data_off))) - else: - data = config[CONF_DATA] - if isinstance(data, bytes): - data = [HexInt(x) for x in data] - cg.add(var.set_data_on(cg.ArrayInitializer(*data))) + single_state = not isinstance(data, dict) + if single_state: + data = {CONF_TURN_ON: data} + for key, setter in ( + (CONF_TURN_ON, var.set_data_on), + (CONF_TURN_OFF, var.set_data_off), + ): + if payload := data.get(key): + cg.add(setter(automation.progmem_bytes("uart_data", payload), len(payload))) + if single_state: cg.add(var.set_single_state(True)) - if CONF_SEND_EVERY in config: - cg.add(var.set_send_every(config[CONF_SEND_EVERY])) + cg.add_optional(var.set_send_every, config.get(CONF_SEND_EVERY)) diff --git a/components/uart/switch/uart_switch.cpp b/components/uart/switch/uart_switch.cpp index 642bd19..c078e02 100644 --- a/components/uart/switch/uart_switch.cpp +++ b/components/uart/switch/uart_switch.cpp @@ -4,7 +4,7 @@ namespace esphome::uart { -static const char *const TAG = "uart.switch"; +ESPHOME_LOG_TAG(TAG, "uart.switch"); void UARTSwitch::loop() { if (this->send_every_) { @@ -17,13 +17,13 @@ void UARTSwitch::loop() { } void UARTSwitch::write_command_(bool state) { - if (state && !this->data_on_.empty()) { - ESP_LOGD(TAG, "'%s': Sending on data", this->get_name().c_str()); - this->write_array(this->data_on_.data(), this->data_on_.size()); + if (state && this->data_on_len_ != 0) { + ESP_LOGD(TAG, "'%s': Sending on data", LOG_STR_ARG(this->get_log_name())); + this->write_array_progmem(this->data_on_, this->data_on_len_); } - if (!state && !this->data_off_.empty()) { - ESP_LOGD(TAG, "'%s': Sending off data", this->get_name().c_str()); - this->write_array(this->data_off_.data(), this->data_off_.size()); + if (!state && this->data_off_len_ != 0) { + ESP_LOGD(TAG, "'%s': Sending off data", LOG_STR_ARG(this->get_log_name())); + this->write_array_progmem(this->data_off_, this->data_off_len_); } } diff --git a/components/uart/switch/uart_switch.h b/components/uart/switch/uart_switch.h index c924c7d..96d8833 100644 --- a/components/uart/switch/uart_switch.h +++ b/components/uart/switch/uart_switch.h @@ -5,7 +5,6 @@ #include "esphome/components/switch/switch.h" #include -#include namespace esphome::uart { @@ -13,10 +12,14 @@ class UARTSwitch final : public switch_::Switch, public UARTDevice, public Compo public: void loop() override; - void set_data_on(std::vector &&data) { this->data_on_ = std::move(data); } - void set_data_on(std::initializer_list data) { this->data_on_ = std::vector(data); } - void set_data_off(std::vector &&data) { this->data_off_ = std::move(data); } - void set_data_off(std::initializer_list data) { this->data_off_ = std::vector(data); } + void set_data_on(const uint8_t *data, uint16_t len) { + this->data_on_ = data; + this->data_on_len_ = len; + } + void set_data_off(const uint8_t *data, uint16_t len) { + this->data_off_ = data; + this->data_off_len_ = len; + } void set_send_every(uint32_t send_every) { this->send_every_ = send_every; } void set_single_state(bool single) { this->single_state_ = single; } @@ -25,8 +28,10 @@ class UARTSwitch final : public switch_::Switch, public UARTDevice, public Compo protected: void write_command_(bool state); void write_state(bool state) override; - std::vector data_on_; - std::vector data_off_; + const uint8_t *data_on_{nullptr}; + const uint8_t *data_off_{nullptr}; + uint16_t data_on_len_{0}; + uint16_t data_off_len_{0}; bool single_state_{false}; uint32_t send_every_; uint32_t last_transmission_; diff --git a/components/uart/uart.cpp b/components/uart/uart.cpp index 44bc99a..1c545af 100644 --- a/components/uart/uart.cpp +++ b/components/uart/uart.cpp @@ -8,7 +8,7 @@ namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); // UART parity strings indexed by UARTParityOptions enum (0-4): NONE, EVEN, ODD, MARK, SPACE PROGMEM_STRING_TABLE(UARTParityStrings, "NONE", "EVEN", "ODD", "MARK", "SPACE", "UNKNOWN"); @@ -33,6 +33,13 @@ void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UART } } +void UARTDevice::discard_available() { + UARTComponent *parent = this->parent_; + uint8_t byte; + while (parent->available() && parent->read_byte(&byte)) { + } +} + const LogString *parity_to_str(UARTParityOptions parity) { return UARTParityStrings::get_log_str(static_cast(parity), UARTParityStrings::LAST_INDEX); } diff --git a/components/uart/uart.h b/components/uart/uart.h index d1c6773..e8f9830 100644 --- a/components/uart/uart.h +++ b/components/uart/uart.h @@ -1,5 +1,8 @@ #pragma once +#include +#include +#include #include #include "esphome/core/component.h" #include "esphome/core/hal.h" @@ -25,6 +28,7 @@ class UARTDevice { size_t get_rx_timeout() { return this->parent_->get_rx_timeout(); } void write_array(const uint8_t *data, size_t len) { this->parent_->write_array(data, len); } + void write_array_progmem(const uint8_t *data, size_t len) { this->parent_->write_array_progmem(data, len); } void write_array(const std::vector &data) { this->parent_->write_array(data); } template void write_array(const std::array &data) { this->parent_->write_array(data.data(), data.size()); @@ -47,6 +51,48 @@ class UARTDevice { size_t available() { return this->parent_->available(); } + /// Pass the bytes available now to on_chunk(data, len) in N byte chunks; returning false stops. + /// Returns false only on a read error. + template bool read_available_chunks(F &&on_chunk) { + return this->read_available_chunks(on_chunk, this->available()); + } + /// Same, reading exactly count bytes; count must not exceed available(). + template bool read_available_chunks(F &&on_chunk, size_t count) { + static_assert(N > 0, "read buffer size must be non-zero"); + uint8_t buf[N]; + while (count > 0) { + const size_t len = std::min(count, N); + if (!this->read_array(buf, len)) { + return false; + } + count -= len; + if (!continue_after(on_chunk, static_cast(buf), len)) { + break; + } + } + return true; + } + + /// Same as read_available_chunks(), calling on_byte(uint8_t) once per byte. + template bool read_available(F &&on_byte) { + return this->read_available(on_byte, this->available()); + } + template bool read_available(F &&on_byte, size_t count) { + return this->read_available_chunks( + [&on_byte](const uint8_t *data, size_t len) { + for (const uint8_t *p = data; p != data + len; p++) { + if (!continue_after(on_byte, *p)) { + return false; + } + } + return true; + }, + count); + } + + /// Read and drop every byte waiting in the receive buffer. + void discard_available(); + UARTFlushResult flush() { return this->parent_->flush(); } // Compat APIs @@ -73,6 +119,18 @@ class UARTDevice { UARTParityOptions parity = UART_CONFIG_PARITY_NONE, uint8_t data_bits = 8); protected: + /// Call f(args...) and return its result; a void callback always continues. + template static bool continue_after(F &f, A... args) { + using R = std::invoke_result_t; + if constexpr (std::is_void_v) { + f(args...); + return true; + } else { + static_assert(std::is_same_v, bool>, "callback must return void or bool"); + return f(args...); + } + } + UARTComponent *parent_{nullptr}; }; diff --git a/components/uart/uart_component.cpp b/components/uart/uart_component.cpp index 762e56c..e77e37c 100644 --- a/components/uart/uart_component.cpp +++ b/components/uart/uart_component.cpp @@ -1,8 +1,14 @@ #include "uart_component.h" +#include "esphome/core/application.h" + +#include namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); + +// Keeps the pacing product in 32 bits up to about 10 Mbaud. +static constexpr uint32_t MAX_PACE_SPAN_MS = 4000; bool UARTComponent::check_read_timeout_(size_t len) { if (this->available() >= len) @@ -19,6 +25,19 @@ bool UARTComponent::check_read_timeout_(size_t len) { return true; } +size_t UARTComponent::paced_write_room(uint32_t last_write_ms) { + size_t room = this->available_for_write(); + if (room != SIZE_MAX) { + return room; + } + // A pass woken early writes little. + uint32_t span = + std::min({App.get_loop_component_start_time() - last_write_ms, App.get_loop_interval(), MAX_PACE_SPAN_MS}); + // 10 bits per byte on the line. + uint32_t paced = this->baud_rate_ / 10 * span / 1000; + return std::max(1, paced); +} + void UARTComponent::set_rx_full_threshold_ms(uint8_t time) { uint8_t bytelength = this->data_bits_ + this->stop_bits_ + 1; if (this->parity_ != UARTParityOptions::UART_CONFIG_PARITY_NONE) @@ -27,4 +46,17 @@ void UARTComponent::set_rx_full_threshold_ms(uint8_t time) { this->set_rx_full_threshold(val); } +#ifdef USE_ESP8266 +void UARTComponent::write_array_progmem(const uint8_t *data, size_t len) { + uint8_t buf[32]; + while (len > 0) { + const size_t chunk = std::min(len, sizeof(buf)); + progmem_memcpy(buf, data, chunk); + this->write_array(buf, chunk); + data += chunk; + len -= chunk; + } +} +#endif + } // namespace esphome::uart diff --git a/components/uart/uart_component.h b/components/uart/uart_component.h index 2dfbf9c..1bd7a96 100644 --- a/components/uart/uart_component.h +++ b/components/uart/uart_component.h @@ -23,6 +23,14 @@ enum UARTParityOptions { UART_CONFIG_PARITY_SPACE, }; +// A runtime setting like CRTSCTS and IXON/IXOFF in termios. A backend without the lines +// keeps the value and ignores it, as a Linux driver does. +enum UARTFlowControl : uint8_t { + UART_FLOW_CONTROL_NONE, + UART_FLOW_CONTROL_RTS_CTS, + UART_FLOW_CONTROL_XON_XOFF, +}; + #ifdef USE_UART_DEBUGGER enum UARTDirection { UART_DIRECTION_RX, @@ -65,6 +73,13 @@ class UARTComponent { // @param len Length of the array. virtual void write_array(const uint8_t *data, size_t len) = 0; + // Writes bytes that may live in PROGMEM; ESP8266 cannot read flash bytewise, so it copies chunks. +#ifdef USE_ESP8266 + void write_array_progmem(const uint8_t *data, size_t len); +#else + void write_array_progmem(const uint8_t *data, size_t len) { this->write_array(data, len); } +#endif + // Reads a single byte from the UART bus. // @param data Pointer to the byte where the read data will be stored. // @return True if a byte was successfully read, false otherwise. @@ -89,6 +104,10 @@ class UARTComponent { // Platforms that cannot tell return SIZE_MAX: write_array() takes everything and may block. virtual size_t available_for_write() { return SIZE_MAX; } + // Bytes a write can take now. Where available_for_write() cannot tell (SIZE_MAX), paces to the line time since + // last_write_ms, a loop start time: at most one loop interval and 4 s, at least one byte. + size_t paced_write_room(uint32_t last_write_ms); + // Pure virtual method to block until all bytes have been written to the UART bus. // @return UARTFlushResult indicating whether the flush was confirmed, timed out, failed, or assumed successful. virtual UARTFlushResult flush() = 0; @@ -174,6 +193,15 @@ class UARTComponent { // @return Baud rate in bits per second. uint32_t get_baud_rate() const { return baud_rate_; } + // Set the line handshaking (RTS/CTS or XON/XOFF) used in UART communication. Unrelated to + // flow_control_pin, the RS485 driver enable; backends without handshaking ignore it. + // @param flow_control Flow control option. + void set_flow_control(UARTFlowControl flow_control) { this->flow_control_ = flow_control; } + + // Get the flow control used in UART communication. + // @return Flow control option. + UARTFlowControl get_flow_control() const { return this->flow_control_; } + #if defined(USE_ESP8266) || defined(USE_ESP32) /** * Load the UART settings. @@ -220,6 +248,7 @@ class UARTComponent { uint32_t baud_rate_{0}; uint8_t stop_bits_{0}; uint8_t data_bits_{0}; + UARTFlowControl flow_control_{UART_FLOW_CONTROL_NONE}; UARTParityOptions parity_{UART_CONFIG_PARITY_NONE}; // Must match the parity check in __init__.py #ifdef USE_UART_DEBUGGER CallbackManager debug_callback_{}; diff --git a/components/uart/uart_component_esp8266.cpp b/components/uart/uart_component_esp8266.cpp index 0819a1b..85c62df 100644 --- a/components/uart/uart_component_esp8266.cpp +++ b/components/uart/uart_component_esp8266.cpp @@ -1,6 +1,7 @@ #ifdef USE_ESP8266 #include "uart_component_esp8266.h" #include +#include #include "esphome/core/application.h" #include "esphome/core/defines.h" #include "esphome/core/helpers.h" @@ -18,12 +19,23 @@ namespace esphome::uart { ESPHOME_LOG_TAG(TAG, "uart"); // Edge decoder up to this baud rate; at 38400 WiFi interrupt latency corrupts bytes. static constexpr uint32_t SW_SERIAL_EDGE_MODE_MAX_BAUD = 19200; +// TX locks interrupts per bit up to this baud rate and per byte above it. At 38400 byte locks still trip the Wi-Fi +// watchdog when every byte is below 0x80, while an interrupt between bits leaves the bytes intact; at 115200 it +// stretches bits enough to corrupt them. +static constexpr uint32_t SW_SERIAL_TX_BIT_LOCK_MAX_BAUD = 38400; // Edge decoder time base: 1/16 us from the 1 MHz system timer, which keeps its rate during a // CpuFrequencyBoost; the cycle counter does not. static constexpr uint32_t RX_TICKS_PER_SECOND = 16000000; +// A byte lock lets pending interrupts run right after an edge when the next edge is at least this far away, so their +// delay lands inside a run of equal bits. Locks longer than about 6 bits at 57600 trip the Wi-Fi watchdog. +static constexpr uint32_t TX_UNLOCK_MIN_RUN_CYCLES = F_CPU / 1000000 * 30; +// Longest per-bit TX interrupt lock; the Wi-Fi interrupt handler asserts (hardware WDT) when held off about 1 ms +static constexpr uint32_t MAX_TX_LOCK_CYCLES = F_CPU / 1000000 * 200; __attribute__((always_inline)) static inline uint32_t rx_now() { return micros() << 4; } bool ESP8266UartComponent::serial0_in_use = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) +bool ESP8266UartComponent::serial0_swapped = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) + uint32_t ESP8266UartComponent::get_config() { uint32_t config = 0; @@ -111,6 +123,7 @@ void ESP8266UartComponent::setup() { this->hw_serial_->setRxBufferSize(this->rx_buffer_size_); this->hw_serial_->swap(); ESP8266UartComponent::serial0_in_use = true; + ESP8266UartComponent::serial0_swapped = true; } else #endif // USE_ESP8266_UART_SERIAL #ifdef USE_ESP8266_UART_SERIAL1 @@ -133,6 +146,11 @@ void ESP8266UartComponent::load_settings(bool dump_config) { SerialConfig config = static_cast(get_config()); this->hw_serial_->begin(this->baud_rate_, config); this->hw_serial_->setRxBufferSize(this->rx_buffer_size_); +#ifdef USE_ESP8266_UART_SERIAL + // begin() puts UART0 back on GPIO1/GPIO3, so swap it again like setup() did for GPIO15/GPIO13 + if (this->hw_serial_ == &Serial && ESP8266UartComponent::serial0_swapped) + this->hw_serial_->swap(); +#endif // USE_ESP8266_UART_SERIAL } else { this->sw_serial_->setup(this->tx_pin_, this->rx_pin_, this->baud_rate_, this->stop_bits_, this->data_bits_, this->parity_, this->rx_buffer_size_); @@ -169,6 +187,13 @@ void ESP8266UartComponent::dump_config() { this->baud_rate_ <= SW_SERIAL_EDGE_MODE_MAX_BAUD ? LOG_STR_LITERAL("edge") : LOG_STR_LITERAL("start bit sampler")); } + if (this->tx_pin_ != nullptr && this->baud_rate_ <= SW_SERIAL_TX_BIT_LOCK_MAX_BAUD && + this->sw_serial_->locks_whole_frame()) { + ESP_LOGW(TAG, + " TX locks interrupts for whole bytes because a software UART receives above %u baud; Wi-Fi " + "watchdog resets are possible under load", + (unsigned) SW_SERIAL_EDGE_MODE_MAX_BAUD); + } } this->check_logger_conflict(); } @@ -253,10 +278,19 @@ void ESP8266SoftwareSerial::setup(InternalGPIOPin *tx_pin, InternalGPIOPin *rx_p // load_settings() re-enters here if (this->gpio_rx_pin_ != nullptr) this->gpio_rx_pin_->detach_interrupt(); + // This instance counted itself if its RX ran the whole-byte interrupt + if (this->blocking_rx_ && this->gpio_rx_pin_ != nullptr) + blocking_rx_count--; + // RX disabled: forget the old pin, so a later reload does not remove this instance from the count again + if (rx_pin == nullptr) + this->gpio_rx_pin_ = nullptr; this->bit_time_ = F_CPU / baud_rate; this->stop_bits_ = stop_bits; this->data_bits_ = data_bits; this->parity_ = parity; + const bool edge_mode = baud_rate <= SW_SERIAL_EDGE_MODE_MAX_BAUD; + this->blocking_rx_ = !edge_mode; + this->lock_frame_ = baud_rate > SW_SERIAL_TX_BIT_LOCK_MAX_BAUD; // to_isr() allocates, so call it only for a new or changed pin if (tx_pin != nullptr) { if (tx_pin != this->gpio_tx_pin_) @@ -278,10 +312,11 @@ void ESP8266SoftwareSerial::setup(InternalGPIOPin *tx_pin, InternalGPIOPin *rx_p this->rx_.setup((RX_TICKS_PER_SECOND + baud_rate / 2) / baud_rate, data_bits, parity != UART_CONFIG_PARITY_NONE, stop_bits, buffer, rx_buffer_size); this->rx_.reset(rx_now(), this->rx_pin_.digital_read()); - if (baud_rate <= SW_SERIAL_EDGE_MODE_MAX_BAUD) { + if (edge_mode) { gpio_rx_pin_->attach_interrupt(ESP8266SoftwareSerial::gpio_intr_edge, this, gpio::INTERRUPT_ANY_EDGE); } else { gpio_rx_pin_->attach_interrupt(ESP8266SoftwareSerial::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE); + blocking_rx_count++; } } } @@ -361,27 +396,44 @@ void IRAM_ATTR HOT ESP8266SoftwareSerial::write_byte(uint8_t data) { need_parity_bit = false; } - { - // Transmit runs from the main loop and never overlaps a CpuFrequencyBoost - InterruptLock lock; - const uint32_t bit_time = this->bit_time_; - uint32_t wait = bit_time; - const uint32_t start = arch_get_cpu_cycle_count(); - // Start bit - this->write_bit_(false, &wait, start, bit_time); - for (int i = 0; i < this->data_bits_; i++) { - bool bit = data & (1 << i); - this->write_bit_(bit, &wait, start, bit_time); - if (need_parity_bit) - parity_bit ^= bit; - } - if (need_parity_bit) - this->write_bit_(parity_bit, &wait, start, bit_time); - // Stop bit - this->write_bit_(true, &wait, start, bit_time); - if (this->stop_bits_ == 2) - this->wait_(&wait, start, bit_time); + // Transmit runs from the main loop and never overlaps a CpuFrequencyBoost + const uint32_t bit_time = this->bit_time_; + // Data bits LSB first, then the parity bit + uint32_t frame = data & ((1u << this->data_bits_) - 1); + uint32_t num_bits = this->data_bits_; + if (need_parity_bit) { + parity_bit ^= __builtin_parity(frame); + frame |= uint32_t(parity_bit) << num_bits++; } + // Decided before the start bit so the timed loop only tests a bit + const SoftwareSerialTxFrame tx = software_serial_tx_frame(frame, num_bits, bit_time, TX_UNLOCK_MIN_RUN_CYCLES, + this->lock_frame_ && blocking_rx_count == 0); + const uint32_t line = tx.line; + const uint32_t high_from = tx.high_from; + const uint32_t unlock_at = tx.unlock_at; + std::optional frame_lock; + if (this->locks_whole_frame()) + frame_lock.emplace(); + uint32_t start; + { + InterruptLock lock; + // Start bit + this->tx_pin_.digital_write(false); + start = arch_get_cpu_cycle_count(); + } + uint32_t wait = bit_time; + for (uint32_t pos = 0; pos <= high_from; pos++) { + if (pos != 0) + this->write_bit_((line >> pos) & 1, &wait, start, bit_time); + if ((unlock_at >> pos) & 1) + frame_lock.emplace(); // drops the held lock first, so pending interrupts run + } + this->write_bit_(true, &wait, start, bit_time); + // Hold that high run with interrupts on: one that runs past it only delays the next start bit, and back-to-back + // byte locks with no gap between them trip the Wi-Fi watchdog + frame_lock.reset(); + for (uint32_t i = high_from; i < num_bits + this->stop_bits_; i++) + this->wait_(&wait, start, bit_time); } void IRAM_ATTR ESP8266SoftwareSerial::wait_(uint32_t *wait, const uint32_t &start, uint32_t bit_time) { while (arch_get_cpu_cycle_count() - start < *wait) @@ -392,9 +444,14 @@ bool IRAM_ATTR ESP8266SoftwareSerial::read_bit_(uint32_t *wait, const uint32_t & this->wait_(wait, start, bit_time); return this->rx_pin_.digital_read(); } +// Locks only from MAX_TX_LOCK_CYCLES before the edge to the edge, so a pending interrupt runs right after it; a bit +// longer than that (below about 5000 baud) spins with interrupts on first. Nests inside a frame lock. void IRAM_ATTR ESP8266SoftwareSerial::write_bit_(bool bit, uint32_t *wait, const uint32_t &start, uint32_t bit_time) { - this->tx_pin_.digital_write(bit); + while (arch_get_cpu_cycle_count() - start + MAX_TX_LOCK_CYCLES < *wait) + ; + InterruptLock lock; this->wait_(wait, start, bit_time); + this->tx_pin_.digital_write(bit); } uint8_t ESP8266SoftwareSerial::read_byte() { this->rx_sync_(); diff --git a/components/uart/uart_component_esp8266.h b/components/uart/uart_component_esp8266.h index 3d4a2ba..6bf3f08 100644 --- a/components/uart/uart_component_esp8266.h +++ b/components/uart/uart_component_esp8266.h @@ -8,6 +8,7 @@ #include "esphome/core/hal.h" #include "esphome/core/log.h" #include "software_serial_rx_decoder.h" +#include "software_serial_tx_frame.h" #include "uart_component.h" namespace esphome::uart { @@ -26,6 +27,10 @@ class ESP8266SoftwareSerial { size_t available(); + /// TX holds interrupts off for each byte up to the edge into its trailing run of 1 bits, rather than per bit: above + /// the per-bit lock limit, or while any instance's RX interrupt reads whole bytes (it must not run between TX edges). + bool locks_whole_frame() const { return this->lock_frame_ || blocking_rx_count != 0; } + protected: /// Above SW_SERIAL_EDGE_MODE_MAX_BAUD; reads the whole byte in the ISR. static void gpio_intr(ESP8266SoftwareSerial *arg); @@ -51,6 +56,9 @@ class ESP8266SoftwareSerial { UARTParityOptions parity_; uint8_t stop_bits_; uint8_t data_bits_; + bool lock_frame_{false}; + bool blocking_rx_{false}; // this instance's RX reads whole bytes in its interrupt + static inline uint8_t blocking_rx_count = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) }; class ESP8266UartComponent final : public UARTComponent, public Component { @@ -92,7 +100,8 @@ class ESP8266UartComponent final : public UARTComponent, public Component { ESP8266SoftwareSerial *sw_serial_{nullptr}; private: - static bool serial0_in_use; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) + static bool serial0_in_use; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) + static bool serial0_swapped; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) }; } // namespace esphome::uart diff --git a/components/uart/uart_component_esp_idf.cpp b/components/uart/uart_component_esp_idf.cpp index 5d90fc1..cccb728 100644 --- a/components/uart/uart_component_esp_idf.cpp +++ b/components/uart/uart_component_esp_idf.cpp @@ -23,7 +23,7 @@ namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); /// Check if a pin number matches one of the default UART0 GPIO pins. /// These pins may have residual IOMUX state from the ROM bootloader that @@ -238,6 +238,10 @@ void IDFUARTComponent::load_settings(bool dump_config) { this->mark_failed(); return; } +#ifdef USE_GPIO_HOLD + // Release held pins so the UART peripheral can drive them + this->set_pins_hold_(false); +#endif #ifdef USE_UART_WAKE_LOOP_ON_RX // Register ISR callback to wake the main loop when UART data arrives. @@ -514,7 +518,20 @@ void IDFUARTComponent::on_shutdown() { if (err != ESP_OK) { ESP_LOGW(TAG, "uart_driver_delete failed: %s", esp_err_to_name(err)); } +#ifdef USE_GPIO_HOLD + // Hold the pins again so they keep their state through the reset + this->set_pins_hold_(true); +#endif } +#ifdef USE_GPIO_HOLD +void IDFUARTComponent::set_pins_hold_(bool hold) { + for (auto *pin : {this->tx_pin_, this->rx_pin_, this->flow_control_pin_}) { + if (pin != nullptr) + pin->set_hold(hold); + } +} +#endif + } // namespace esphome::uart #endif // USE_ESP32 diff --git a/components/uart/uart_component_esp_idf.h b/components/uart/uart_component_esp_idf.h index 7c93b74..260117c 100644 --- a/components/uart/uart_component_esp_idf.h +++ b/components/uart/uart_component_esp_idf.h @@ -90,6 +90,9 @@ class IDFUARTComponent final : public UARTComponent, public Component { protected: void check_logger_conflict() override; +#ifdef USE_GPIO_HOLD + void set_pins_hold_(bool hold); +#endif uint32_t line_inversion_mask_(); // Re-applies what uart_param_config() resets: inversion, RX threshold/timeout, mode. esp_err_t apply_line_settings_(); diff --git a/components/uart/uart_component_host.cpp b/components/uart/uart_component_host.cpp index bf9ab2d..bc6ff63 100644 --- a/components/uart/uart_component_host.cpp +++ b/components/uart/uart_component_host.cpp @@ -9,11 +9,11 @@ #error This HostUartComponent implementation is not supported on this host OS #endif -#include -#include +#include +#include +#include #include #include -#include #include #include @@ -98,7 +98,7 @@ speed_t get_baud(int baud) { namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); HostUartComponent::~HostUartComponent() { if (this->file_descriptor_ != -1) { @@ -162,11 +162,7 @@ void HostUartComponent::setup() { break; }; // Set stop bits - if (this->stop_bits_ == 2) { - options.c_cflag |= CSTOPB; - } else { - options.c_cflag &= ~CSTOPB; - } + assign_bits(options.c_cflag, CSTOPB, this->stop_bits_ == 2); cfsetispeed(&options, baud); cfsetospeed(&options, baud); tcsetattr(this->file_descriptor_, TCSANOW, &options); @@ -210,7 +206,6 @@ void HostUartComponent::write_array(const uint8_t *data, size_t len) { this->debug_callback_.call(UART_DIRECTION_TX, data[i]); } #endif - return; } bool HostUartComponent::peek_byte(uint8_t *data) { @@ -286,6 +281,36 @@ UARTFlushResult HostUartComponent::flush() { return UARTFlushResult::UART_FLUSH_RESULT_SUCCESS; } +bool HostUartComponent::set_modem_control(bool dtr, bool rts) { + if (this->file_descriptor_ == -1) { + return false; + } + // One TIOCMSET so the device never sees a state in between the old and the new one + int bits; + if (ioctl(this->file_descriptor_, TIOCMGET, &bits) == -1) { + this->update_error_(strerror(errno)); + return false; + } + bits = (bits & ~(TIOCM_DTR | TIOCM_RTS)) | (dtr ? TIOCM_DTR : 0) | (rts ? TIOCM_RTS : 0); + if (ioctl(this->file_descriptor_, TIOCMSET, &bits) == -1) { + this->update_error_(strerror(errno)); + return false; + } + return true; +} + +bool HostUartComponent::get_dtr() const { return (this->get_modem_bits_() & TIOCM_DTR) != 0; } + +bool HostUartComponent::get_rts() const { return (this->get_modem_bits_() & TIOCM_RTS) != 0; } + +int HostUartComponent::get_modem_bits_() const { + int bits = 0; + if (this->file_descriptor_ != -1) { + ioctl(this->file_descriptor_, TIOCMGET, &bits); + } + return bits; +} + void HostUartComponent::update_error_(const std::string &error) { if (this->first_error_.empty()) { this->first_error_ = error; diff --git a/components/uart/uart_component_host.h b/components/uart/uart_component_host.h index bca62de..55e89d8 100644 --- a/components/uart/uart_component_host.h +++ b/components/uart/uart_component_host.h @@ -2,6 +2,8 @@ #ifdef USE_HOST +#include + #include "esphome/core/component.h" #include "esphome/core/log.h" #include "uart_component.h" @@ -10,7 +12,7 @@ namespace esphome::uart { class HostUartComponent final : public UARTComponent, public Component { public: - virtual ~HostUartComponent(); + ~HostUartComponent(); void setup() override; void dump_config() override; float get_setup_priority() const override { return setup_priority::BUS; } @@ -19,10 +21,15 @@ class HostUartComponent final : public UARTComponent, public Component { bool read_array(uint8_t *data, size_t len) override; size_t available() override; UARTFlushResult flush() override; - void set_name(std::string port_name) { port_name_ = port_name; }; + /// Drive DTR/RTS. Returns false when the port is closed or the ioctl fails. + bool set_modem_control(bool dtr, bool rts); + bool get_dtr() const; + bool get_rts() const; + void set_name(std::string port_name) { this->port_name_ = std::move(port_name); } protected: void update_error_(const std::string &error); + int get_modem_bits_() const; void check_logger_conflict() override {} std::string port_name_; std::string first_error_; diff --git a/components/uart/uart_component_libretiny.cpp b/components/uart/uart_component_libretiny.cpp index 280bafc..8e0625d 100644 --- a/components/uart/uart_component_libretiny.cpp +++ b/components/uart/uart_component_libretiny.cpp @@ -18,7 +18,7 @@ namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); static const char *const UART_TYPE[] = { "hardware", diff --git a/components/uart/uart_component_rp2.cpp b/components/uart/uart_component_rp2.cpp index ffb9bc0..07245bc 100644 --- a/components/uart/uart_component_rp2.cpp +++ b/components/uart/uart_component_rp2.cpp @@ -13,7 +13,7 @@ namespace esphome::uart { -static const char *const TAG = "uart"; +ESPHOME_LOG_TAG(TAG, "uart"); uint16_t RP2UartComponent::get_config() { uint16_t config = 0; diff --git a/components/uart/uart_debugger.cpp b/components/uart/uart_debugger.cpp index e0be599..cf1fac1 100644 --- a/components/uart/uart_debugger.cpp +++ b/components/uart/uart_debugger.cpp @@ -3,12 +3,13 @@ #include #include "uart_debugger.h" +#include "esphome/core/hal.h" #include "esphome/core/helpers.h" #include "esphome/core/log.h" namespace esphome::uart { -static const char *const TAG = "uart_debug"; +ESPHOME_LOG_TAG(TAG, "uart_debug"); UARTDebugger::UARTDebugger(UARTComponent *parent) { parent->add_debug_callback([this](UARTDirection direction, uint8_t byte) { @@ -44,15 +45,15 @@ void UARTDebugger::store_byte_(UARTDirection direction, uint8_t byte) { } void UARTDebugger::trigger_after_delimiter_(uint8_t byte) { - if (this->after_delimiter_.empty() || !this->has_buffered_bytes_()) { + if (this->after_delimiter_len_ == 0 || !this->has_buffered_bytes_()) { return; } - if (this->after_delimiter_[this->after_delimiter_pos_] != byte) { + if (progmem_read_byte(this->after_delimiter_ + this->after_delimiter_pos_) != byte) { this->after_delimiter_pos_ = 0; return; } this->after_delimiter_pos_++; - if (this->after_delimiter_pos_ == this->after_delimiter_.size()) { + if (this->after_delimiter_pos_ == this->after_delimiter_len_) { this->fire_trigger_(); this->after_delimiter_pos_ = 0; } diff --git a/components/uart/uart_debugger.h b/components/uart/uart_debugger.h index b69dcf0..7a96779 100644 --- a/components/uart/uart_debugger.h +++ b/components/uart/uart_debugger.h @@ -36,11 +36,13 @@ class UARTDebugger final : public Component, public Triggerafter_timeout_ = timeout; } - /// Add a delimiter byte. This can be called multiple times to setup a - /// multi-byte delimiter (a typical example would be '\r\n'). - /// When the constructed byte sequence is found in the data stream, - /// logging will be triggered. - void add_delimiter_byte(uint8_t byte) { this->after_delimiter_.push_back(byte); } + /// Set a delimiter byte sequence (a typical example would be '\r\n'). + /// When the sequence is found in the data stream, logging will be triggered. + /// `delimiter` is a codegen PROGMEM table that must outlive the debugger. + void set_after_delimiter(const uint8_t *delimiter, uint8_t len) { + this->after_delimiter_ = delimiter; + this->after_delimiter_len_ = len; + } void set_debug_prefix(const char *prefix) { this->debug_prefix_ = StringRef(prefix); } @@ -51,8 +53,9 @@ class UARTDebugger final : public Component, public Trigger after_delimiter_{}; - size_t after_delimiter_pos_{}; + const uint8_t *after_delimiter_{nullptr}; + uint8_t after_delimiter_len_{0}; + uint8_t after_delimiter_pos_{0}; bool is_triggering_{false}; StringRef debug_prefix_{}; diff --git a/patches/wbr3-pa13-pa14-uart.patch b/patches/wbr3-pa13-pa14-uart.patch index db91577..2d233f4 100644 --- a/patches/wbr3-pa13-pa14-uart.patch +++ b/patches/wbr3-pa13-pa14-uart.patch @@ -1,26 +1,24 @@ --- a/esphome/components/uart/uart_component_libretiny.cpp +++ b/esphome/components/uart/uart_component_libretiny.cpp -@@ -64,8 +64,10 @@ void LibreTinyUARTComponent::setup() { +@@ -74,7 +74,9 @@ return; } #if LT_HW_UART0 - else if ((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX) && -- !should_fallback_to_software_serial()) { + else if ((((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && + (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX)) || + (tx_pin == 14 && rx_pin == 13)) && -+ !should_fallback_to_software_serial()) { + !should_fallback_to_software_serial()) { this->serial_ = &Serial0; this->hardware_idx_ = 0; - } -@@ -111,6 +113,10 @@ void LibreTinyUARTComponent::setup() { - return; - #endif - } +@@ -124,6 +126,10 @@ + + if (this->hardware_idx_ >= 0) + libretiny::ensure_serial_handle(this->hardware_idx_); + if (this->hardware_idx_ == 0 && tx_pin == 14 && rx_pin == 13) { + ESP_LOGI(TAG, "Using alternate UART0 pins RX=PA13 TX=PA14"); + Serial0.setPins(rx_pin, tx_pin); + } this->serial_->begin(this->baud_rate_, get_config()); } - void LibreTinyUARTComponent::dump_config() { + diff --git a/server-example.yaml b/server-example.yaml index 55d861d..3ffd3ba 100644 --- a/server-example.yaml +++ b/server-example.yaml @@ -7,6 +7,6 @@ substitutions: packages: lamp: url: https://mangavalk.com/mangavalk/esphome-wake-up-light-ii.git - ref: v1.0.5 + ref: v1.0.6 files: [wake-up-light-ii.yaml] refresh: 1d diff --git a/wake-up-light-ii.yaml b/wake-up-light-ii.yaml index a80dfa4..944af72 100644 --- a/wake-up-light-ii.yaml +++ b/wake-up-light-ii.yaml @@ -8,7 +8,7 @@ # # Stock ESPHome/LibreTiny UART selection may not route UART0 to PA13/PA14 on # WBR3, so this config loads the patched UART component in components/uart -# (patches/wbr3-pa13-pa14-uart.patch applied to ESPHome 2026.10.2). +# (patches/wbr3-pa13-pa14-uart.patch applied to ESPHome 2026.11.0). ############################################################################### substitutions: @@ -22,7 +22,7 @@ external_components: - source: type: git url: https://mangavalk.com/mangavalk/esphome-wake-up-light-ii.git - ref: v1.0.5 + ref: v1.0.6 components: [uart] refresh: 1d