esphome 2025.9.3__py3-none-any.whl → 2025.10.0b2__py3-none-any.whl

esphome/components/substitutions/jinja.py

@@ -1,9 +1,10 @@
+from ast import literal_eval
 import logging
 import math
 import re
 
 import jinja2 as jinja
-from jinja2.nativetypes import NativeEnvironment
+from jinja2.sandbox import SandboxedEnvironment
 
 TemplateError = jinja.TemplateError
 TemplateSyntaxError = jinja.TemplateSyntaxError
@@ -70,7 +71,7 @@ class Jinja:
     """
 
     def __init__(self, context_vars):
-        self.env = NativeEnvironment(
+        self.env = SandboxedEnvironment(
             trim_blocks=True,
             lstrip_blocks=True,
             block_start_string="<%",
@@ -90,6 +91,15 @@ class Jinja:
             **SAFE_GLOBAL_FUNCTIONS,
         }
 
+    def safe_eval(self, expr):
+        try:
+            result = literal_eval(expr)
+            if not isinstance(result, str):
+                return result
+        except (ValueError, SyntaxError, MemoryError, TypeError):
+            pass
+        return expr
+
     def expand(self, content_str):
         """
         Renders a string that may contain Jinja expressions or statements
@@ -106,7 +116,7 @@ class Jinja:
             override_vars = content_str.upvalues
         try:
             template = self.env.from_string(content_str)
-            result = template.render(override_vars)
+            result = self.safe_eval(template.render(override_vars))
             if isinstance(result, Undefined):
                 # This happens when the expression is simply an undefined variable. Jinja does not
                 # raise an exception, instead we get "Undefined".

esphome/components/sx126x/__init__.py

@@ -15,6 +15,10 @@ CONF_BANDWIDTH = "bandwidth"
 CONF_BITRATE = "bitrate"
 CONF_CODING_RATE = "coding_rate"
 CONF_CRC_ENABLE = "crc_enable"
+CONF_CRC_INVERTED = "crc_inverted"
+CONF_CRC_SIZE = "crc_size"
+CONF_CRC_POLYNOMIAL = "crc_polynomial"
+CONF_CRC_INITIAL = "crc_initial"
 CONF_DEVIATION = "deviation"
 CONF_DIO1_PIN = "dio1_pin"
 CONF_HW_VERSION = "hw_version"
@@ -188,6 +192,14 @@ CONFIG_SCHEMA = (
             cv.Required(CONF_BUSY_PIN): pins.internal_gpio_input_pin_schema,
             cv.Optional(CONF_CODING_RATE, default="CR_4_5"): cv.enum(CODING_RATE),
             cv.Optional(CONF_CRC_ENABLE, default=False): cv.boolean,
+            cv.Optional(CONF_CRC_INVERTED, default=True): cv.boolean,
+            cv.Optional(CONF_CRC_SIZE, default=2): cv.int_range(min=1, max=2),
+            cv.Optional(CONF_CRC_POLYNOMIAL, default=0x1021): cv.All(
+                cv.hex_int, cv.Range(min=0, max=0xFFFF)
+            ),
+            cv.Optional(CONF_CRC_INITIAL, default=0x1D0F): cv.All(
+                cv.hex_int, cv.Range(min=0, max=0xFFFF)
+            ),
             cv.Optional(CONF_DEVIATION, default=5000): cv.int_range(min=0, max=100000),
             cv.Required(CONF_DIO1_PIN): pins.internal_gpio_input_pin_schema,
             cv.Required(CONF_FREQUENCY): cv.int_range(min=137000000, max=1020000000),
@@ -251,6 +263,10 @@ async def to_code(config):
     cg.add(var.set_shaping(config[CONF_SHAPING]))
     cg.add(var.set_bitrate(config[CONF_BITRATE]))
     cg.add(var.set_crc_enable(config[CONF_CRC_ENABLE]))
+    cg.add(var.set_crc_inverted(config[CONF_CRC_INVERTED]))
+    cg.add(var.set_crc_size(config[CONF_CRC_SIZE]))
+    cg.add(var.set_crc_polynomial(config[CONF_CRC_POLYNOMIAL]))
+    cg.add(var.set_crc_initial(config[CONF_CRC_INITIAL]))
     cg.add(var.set_payload_length(config[CONF_PAYLOAD_LENGTH]))
     cg.add(var.set_preamble_size(config[CONF_PREAMBLE_SIZE]))
     cg.add(var.set_preamble_detect(config[CONF_PREAMBLE_DETECT]))

esphome/components/sx126x/sx126x.cpp

@@ -235,6 +235,16 @@ void SX126x::configure() {
     buf[7] = (fdev >> 0) & 0xFF;
     this->write_opcode_(RADIO_SET_MODULATIONPARAMS, buf, 8);
 
+    // set crc params
+    if (this->crc_enable_) {
+      buf[0] = this->crc_initial_ >> 8;
+      buf[1] = this->crc_initial_ & 0xFF;
+      this->write_register_(REG_CRC_INITIAL, buf, 2);
+      buf[0] = this->crc_polynomial_ >> 8;
+      buf[1] = this->crc_polynomial_ & 0xFF;
+      this->write_register_(REG_CRC_POLYNOMIAL, buf, 2);
+    }
+
     // set packet params and sync word
     this->set_packet_params_(this->get_max_packet_size());
     if (!this->sync_value_.empty()) {
@@ -276,7 +286,11 @@ void SX126x::set_packet_params_(uint8_t payload_length) {
     buf[4] = 0x00;
     buf[5] = (this->payload_length_ > 0) ? 0x00 : 0x01;
     buf[6] = payload_length;
-    buf[7] = this->crc_enable_ ? 0x06 : 0x01;
+    if (this->crc_enable_) {
+      buf[7] = (this->crc_inverted_ ? 0x04 : 0x00) + (this->crc_size_ & 0x02);
+    } else {
+      buf[7] = 0x01;
+    }
     buf[8] = 0x00;
     this->write_opcode_(RADIO_SET_PACKETPARAMS, buf, 9);
   }

esphome/components/sx126x/sx126x.h

@@ -67,6 +67,10 @@ class SX126x : public Component,
   void set_busy_pin(InternalGPIOPin *busy_pin) { this->busy_pin_ = busy_pin; }
   void set_coding_rate(uint8_t coding_rate) { this->coding_rate_ = coding_rate; }
   void set_crc_enable(bool crc_enable) { this->crc_enable_ = crc_enable; }
+  void set_crc_inverted(bool crc_inverted) { this->crc_inverted_ = crc_inverted; }
+  void set_crc_size(uint8_t crc_size) { this->crc_size_ = crc_size; }
+  void set_crc_polynomial(uint16_t crc_polynomial) { this->crc_polynomial_ = crc_polynomial; }
+  void set_crc_initial(uint16_t crc_initial) { this->crc_initial_ = crc_initial; }
   void set_deviation(uint32_t deviation) { this->deviation_ = deviation; }
   void set_dio1_pin(InternalGPIOPin *dio1_pin) { this->dio1_pin_ = dio1_pin; }
   void set_frequency(uint32_t frequency) { this->frequency_ = frequency; }
@@ -118,6 +122,11 @@ class SX126x : public Component,
   char version_[16];
   SX126xBw bandwidth_{SX126X_BW_125000};
   uint32_t bitrate_{0};
+  bool crc_enable_{false};
+  bool crc_inverted_{false};
+  uint8_t crc_size_{0};
+  uint16_t crc_polynomial_{0};
+  uint16_t crc_initial_{0};
   uint32_t deviation_{0};
   uint32_t frequency_{0};
   uint32_t payload_length_{0};
@@ -131,7 +140,6 @@ class SX126x : public Component,
   uint8_t shaping_{0};
   uint8_t spreading_factor_{0};
   int8_t pa_power_{0};
-  bool crc_enable_{false};
   bool rx_start_{false};
   bool rf_switch_{false};
 };

esphome/components/sx126x/sx126x_reg.h

@@ -53,6 +53,8 @@ enum SX126xOpCode : uint8_t {
 
 enum SX126xRegister : uint16_t {
   REG_VERSION_STRING = 0x0320,
+  REG_CRC_INITIAL = 0x06BC,
+  REG_CRC_POLYNOMIAL = 0x06BE,
   REG_GFSK_SYNCWORD = 0x06C0,
   REG_LORA_SYNCWORD = 0x0740,
   REG_OCP = 0x08E7,

esphome/components/text_sensor/text_sensor.cpp

@@ -6,6 +6,22 @@ namespace text_sensor {
 
 static const char *const TAG = "text_sensor";
 
+void log_text_sensor(const char *tag, const char *prefix, const char *type, TextSensor *obj) {
+  if (obj == nullptr) {
+    return;
+  }
+
+  ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
+
+  if (!obj->get_device_class_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  }
+
+  if (!obj->get_icon_ref().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  }
+}
+
 void TextSensor::publish_state(const std::string &state) {
   this->raw_state = state;
   if (this->raw_callback_) {

esphome/components/text_sensor/text_sensor.h

@@ -11,16 +11,9 @@
 namespace esphome {
 namespace text_sensor {
 
-#define LOG_TEXT_SENSOR(prefix, type, obj) \
-  if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_device_class_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
-    } \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
-    } \
-  }
+void log_text_sensor(const char *tag, const char *prefix, const char *type, TextSensor *obj);
+
+#define LOG_TEXT_SENSOR(prefix, type, obj) log_text_sensor(TAG, prefix, LOG_STR_LITERAL(type), obj)
 
 #define SUB_TEXT_SENSOR(name) \
  protected: \

esphome/components/tormatic/tormatic_cover.cpp

@@ -251,7 +251,7 @@ void Tormatic::stop_at_target_() {
 // Read a GateStatus from the unit. The unit only sends messages in response to
 // status requests or commands, so a message needs to be sent first.
 optional<GateStatus> Tormatic::read_gate_status_() {
-  if (this->available() < sizeof(MessageHeader)) {
+  if (this->available() < static_cast<int>(sizeof(MessageHeader))) {
     return {};
   }
 

esphome/components/tuya/select/tuya_select.cpp

@@ -50,7 +50,7 @@ void TuyaSelect::dump_config() {
                 "  Options are:",
                 this->select_id_, this->is_int_ ? "int" : "enum");
   auto options = this->traits.get_options();
-  for (auto i = 0; i < this->mappings_.size(); i++) {
+  for (size_t i = 0; i < this->mappings_.size(); i++) {
     ESP_LOGCONFIG(TAG, "    %i: %s", this->mappings_.at(i), options.at(i).c_str());
   }
 }

esphome/components/tuya/tuya.cpp

@@ -215,12 +215,37 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
         this->send_empty_command_(TuyaCommandType::DATAPOINT_QUERY);
       }
       break;
-    case TuyaCommandType::WIFI_RESET:
-      ESP_LOGE(TAG, "WIFI_RESET is not handled");
-      break;
     case TuyaCommandType::WIFI_SELECT:
-      ESP_LOGE(TAG, "WIFI_SELECT is not handled");
+    case TuyaCommandType::WIFI_RESET: {
+      const bool is_select = (len >= 1);
+      // Send WIFI_SELECT ACK
+      TuyaCommand ack;
+      ack.cmd = is_select ? TuyaCommandType::WIFI_SELECT : TuyaCommandType::WIFI_RESET;
+      ack.payload.clear();
+      this->send_command_(ack);
+      // Establish pairing mode for correct first WIFI_STATE byte, EZ (0x00) default
+      uint8_t first = 0x00;
+      const char *mode_str = "EZ";
+      if (is_select && buffer[0] == 0x01) {
+        first = 0x01;
+        mode_str = "AP";
+      }
+      // Send WIFI_STATE response, MCU exits pairing mode
+      TuyaCommand st;
+      st.cmd = TuyaCommandType::WIFI_STATE;
+      st.payload.resize(1);
+      st.payload[0] = first;
+      this->send_command_(st);
+      st.payload[0] = 0x02;
+      this->send_command_(st);
+      st.payload[0] = 0x03;
+      this->send_command_(st);
+      st.payload[0] = 0x04;
+      this->send_command_(st);
+      ESP_LOGI(TAG, "%s received (%s), replied with WIFI_STATE confirming connection established",
+               is_select ? "WIFI_SELECT" : "WIFI_RESET", mode_str);
       break;
+    }
     case TuyaCommandType::DATAPOINT_DELIVER:
       break;
     case TuyaCommandType::DATAPOINT_REPORT_ASYNC:

esphome/components/uart/__init__.py

@@ -1,3 +1,4 @@
+import math
 import re
 
 from esphome import automation, pins
@@ -14,9 +15,9 @@ from esphome.const import (
     CONF_DIRECTION,
     CONF_DUMMY_RECEIVER,
     CONF_DUMMY_RECEIVER_ID,
+    CONF_FLOW_CONTROL_PIN,
     CONF_ID,
     CONF_INVERT,
-    CONF_INVERTED,
     CONF_LAMBDA,
     CONF_NUMBER,
     CONF_PORT,
@@ -39,9 +40,6 @@ uart_ns = cg.esphome_ns.namespace("uart")
 UARTComponent = uart_ns.class_("UARTComponent")
 
 IDFUARTComponent = uart_ns.class_("IDFUARTComponent", UARTComponent, cg.Component)
-ESP32ArduinoUARTComponent = uart_ns.class_(
-    "ESP32ArduinoUARTComponent", UARTComponent, cg.Component
-)
 ESP8266UartComponent = uart_ns.class_(
     "ESP8266UartComponent", UARTComponent, cg.Component
 )
@@ -53,7 +51,6 @@ HostUartComponent = uart_ns.class_("HostUartComponent", UARTComponent, cg.Compon
 
 NATIVE_UART_CLASSES = (
     str(IDFUARTComponent),
-    str(ESP32ArduinoUARTComponent),
     str(ESP8266UartComponent),
     str(RP2040UartComponent),
     str(LibreTinyUARTComponent),
@@ -119,20 +116,6 @@ def validate_rx_pin(value):
     return value
 
 
-def validate_invert_esp32(config):
-    if (
-        CORE.is_esp32
-        and CORE.using_arduino
-        and CONF_TX_PIN in config
-        and CONF_RX_PIN in config
-        and config[CONF_TX_PIN][CONF_INVERTED] != config[CONF_RX_PIN][CONF_INVERTED]
-    ):
-        raise cv.Invalid(
-            "Different invert values for TX and RX pin are not supported for ESP32 when using Arduino."
-        )
-    return config
-
-
 def validate_host_config(config):
     if CORE.is_host:
         if CONF_TX_PIN in config or CONF_RX_PIN in config:
@@ -151,10 +134,7 @@ def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
     if CORE.is_esp32:
-        if CORE.using_arduino:
-            return cv.declare_id(ESP32ArduinoUARTComponent)(value)
-        if CORE.using_esp_idf:
-            return cv.declare_id(IDFUARTComponent)(value)
+        return cv.declare_id(IDFUARTComponent)(value)
     if CORE.is_rp2040:
         return cv.declare_id(RP2040UartComponent)(value)
     if CORE.is_libretiny:
@@ -174,6 +154,8 @@ UART_PARITY_OPTIONS = {
 CONF_STOP_BITS = "stop_bits"
 CONF_DATA_BITS = "data_bits"
 CONF_PARITY = "parity"
+CONF_RX_FULL_THRESHOLD = "rx_full_threshold"
+CONF_RX_TIMEOUT = "rx_timeout"
 
 UARTDirection = uart_ns.enum("UARTDirection")
 UART_DIRECTIONS = {
@@ -241,8 +223,17 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_BAUD_RATE): cv.int_range(min=1),
             cv.Optional(CONF_TX_PIN): pins.internal_gpio_output_pin_schema,
             cv.Optional(CONF_RX_PIN): validate_rx_pin,
+            cv.Optional(CONF_FLOW_CONTROL_PIN): cv.All(
+                cv.only_on_esp32, pins.internal_gpio_output_pin_schema
+            ),
             cv.Optional(CONF_PORT): cv.All(validate_port, cv.only_on(PLATFORM_HOST)),
             cv.Optional(CONF_RX_BUFFER_SIZE, default=256): cv.validate_bytes,
+            cv.Optional(CONF_RX_FULL_THRESHOLD): cv.All(
+                cv.only_on_esp32, cv.validate_bytes, cv.int_range(min=1, max=120)
+            ),
+            cv.SplitDefault(CONF_RX_TIMEOUT, esp32=2): cv.All(
+                cv.only_on_esp32, cv.validate_bytes, cv.int_range(min=0, max=92)
+            ),
             cv.Optional(CONF_STOP_BITS, default=1): cv.one_of(1, 2, int=True),
             cv.Optional(CONF_DATA_BITS, default=8): cv.int_range(min=5, max=8),
             cv.Optional(CONF_PARITY, default="NONE"): cv.enum(
@@ -255,7 +246,6 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
-    validate_invert_esp32,
     validate_host_config,
 )
 
@@ -298,9 +288,27 @@ async def to_code(config):
     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]))
     cg.add(var.set_rx_buffer_size(config[CONF_RX_BUFFER_SIZE]))
+    if CORE.is_esp32:
+        if CONF_RX_FULL_THRESHOLD not in config:
+            # Calculate rx_full_threshold to be 10ms
+            bytelength = config[CONF_DATA_BITS] + config[CONF_STOP_BITS] + 1
+            if config[CONF_PARITY] != "NONE":
+                bytelength += 1
+            config[CONF_RX_FULL_THRESHOLD] = max(
+                1,
+                min(
+                    120,
+                    math.floor((config[CONF_BAUD_RATE] / (bytelength * 1000 / 10)) - 1),
+                ),
+            )
+        cg.add(var.set_rx_full_threshold(config[CONF_RX_FULL_THRESHOLD]))
+        cg.add(var.set_rx_timeout(config[CONF_RX_TIMEOUT]))
     cg.add(var.set_stop_bits(config[CONF_STOP_BITS]))
     cg.add(var.set_data_bits(config[CONF_DATA_BITS]))
     cg.add(var.set_parity(config[CONF_PARITY]))
@@ -339,7 +347,7 @@ def final_validate_device_schema(
 
     def validate_pin(opt, device):
         def validator(value):
-            if opt in device:
+            if opt in device and not CORE.testing_mode:
                 raise cv.Invalid(
                     f"The uart {opt} is used both by {name} and {device[opt]}, "
                     f"but can only be used by one. Please create a new uart bus for {name}."
@@ -444,8 +452,10 @@ async def uart_write_to_code(config, action_id, template_arg, args):
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(
     {
-        "uart_component_esp32_arduino.cpp": {PlatformFramework.ESP32_ARDUINO},
-        "uart_component_esp_idf.cpp": {PlatformFramework.ESP32_IDF},
+        "uart_component_esp_idf.cpp": {
+            PlatformFramework.ESP32_IDF,
+            PlatformFramework.ESP32_ARDUINO,
+        },
         "uart_component_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
         "uart_component_host.cpp": {PlatformFramework.HOST_NATIVE},
         "uart_component_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},

esphome/components/uart/uart.h

@@ -18,6 +18,12 @@ class UARTDevice {
 
   void write_byte(uint8_t data) { this->parent_->write_byte(data); }
 
+  void set_rx_full_threshold(size_t rx_full_threshold) { this->parent_->set_rx_full_threshold(rx_full_threshold); }
+  void set_rx_full_threshold_ms(size_t time) { this->parent_->set_rx_full_threshold_ms(time); }
+  size_t get_rx_full_threshold() { return this->parent_->get_rx_full_threshold(); }
+  void set_rx_timeout(size_t rx_timeout) { this->parent_->set_rx_timeout(rx_timeout); }
+  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(const std::vector<uint8_t> &data) { this->parent_->write_array(data); }
   template<size_t N> void write_array(const std::array<uint8_t, N> &data) {

esphome/components/uart/uart_component.cpp

@@ -20,5 +20,13 @@ bool UARTComponent::check_read_timeout_(size_t len) {
   return true;
 }
 
+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)
+    bytelength += 1;
+  int32_t val = clamp<int32_t>((this->baud_rate_ / (bytelength * 1000 / time)) - 1, 1, 120);
+  this->set_rx_full_threshold(val);
+}
+
 }  // namespace uart
 }  // namespace esphome

esphome/components/uart/uart_component.h

@@ -6,6 +6,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #ifdef USE_UART_DEBUGGER
 #include "esphome/core/automation.h"
 #endif
@@ -82,6 +83,10 @@ class UARTComponent {
   // @param rx_pin Pointer to the internal GPIO pin used for reception.
   void set_rx_pin(InternalGPIOPin *rx_pin) { this->rx_pin_ = rx_pin; }
 
+  // Sets the flow control pin for the UART bus.
+  // @param flow_control_pin Pointer to the internal GPIO pin used for flow control.
+  void set_flow_control_pin(InternalGPIOPin *flow_control_pin) { this->flow_control_pin_ = flow_control_pin; }
+
   // Sets the size of the RX buffer.
   // @param rx_buffer_size Size of the RX buffer in bytes.
   void set_rx_buffer_size(size_t rx_buffer_size) { this->rx_buffer_size_ = rx_buffer_size; }
@@ -90,6 +95,26 @@ class UARTComponent {
   // @return Size of the RX buffer in bytes.
   size_t get_rx_buffer_size() { return this->rx_buffer_size_; }
 
+  // Sets the RX FIFO full interrupt threshold.
+  // @param rx_full_threshold RX full interrupt threshold in bytes.
+  virtual void set_rx_full_threshold(size_t rx_full_threshold) {}
+
+  // Sets the RX FIFO full interrupt threshold.
+  // @param time RX full interrupt threshold in ms.
+  void set_rx_full_threshold_ms(uint8_t time);
+
+  // Gets the RX FIFO full interrupt threshold.
+  // @return RX full interrupt threshold in bytes.
+  size_t get_rx_full_threshold() { return this->rx_full_threshold_; }
+
+  // Sets the RX timeout interrupt threshold.
+  // @param rx_timeout RX timeout interrupt threshold (unit: time of sending one byte).
+  virtual void set_rx_timeout(size_t rx_timeout) {}
+
+  // Gets the RX timeout interrupt threshold.
+  // @return RX timeout interrupt threshold (unit: time of sending one byte).
+  size_t get_rx_timeout() { return this->rx_timeout_; }
+
   // Sets the number of stop bits used in UART communication.
   // @param stop_bits Number of stop bits.
   void set_stop_bits(uint8_t stop_bits) { this->stop_bits_ = stop_bits; }
@@ -161,7 +186,10 @@ class UARTComponent {
 
   InternalGPIOPin *tx_pin_;
   InternalGPIOPin *rx_pin_;
+  InternalGPIOPin *flow_control_pin_;
   size_t rx_buffer_size_;
+  size_t rx_full_threshold_{1};
+  size_t rx_timeout_{0};
   uint32_t baud_rate_;
   uint8_t stop_bits_;
   uint8_t data_bits_;

esphome/components/uart/uart_component_esp_idf.cpp

@@ -1,4 +1,4 @@
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include "uart_component_esp_idf.h"
 #include <cinttypes>
@@ -90,6 +90,12 @@ void IDFUARTComponent::setup() {
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
 
+  this->load_settings(false);
+
+  xSemaphoreGive(this->lock_);
+}
+
+void IDFUARTComponent::load_settings(bool dump_config) {
   uart_config_t uart_config = this->get_config_();
   esp_err_t err = uart_param_config(this->uart_num_, &uart_config);
   if (err != ESP_OK) {
@@ -100,6 +106,7 @@ void IDFUARTComponent::setup() {
 
   int8_t tx = this->tx_pin_ != nullptr ? this->tx_pin_->get_pin() : -1;
   int8_t rx = this->rx_pin_ != nullptr ? this->rx_pin_->get_pin() : -1;
+  int8_t flow_control = this->flow_control_pin_ != nullptr ? this->flow_control_pin_->get_pin() : -1;
 
   uint32_t invert = 0;
   if (this->tx_pin_ != nullptr && this->tx_pin_->is_inverted())
@@ -114,13 +121,21 @@ void IDFUARTComponent::setup() {
     return;
   }
 
-  err = uart_set_pin(this->uart_num_, tx, rx, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+  err = uart_set_pin(this->uart_num_, tx, rx, flow_control, UART_PIN_NO_CHANGE);
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_set_pin failed: %s", esp_err_to_name(err));
     this->mark_failed();
     return;
   }
 
+  if (uart_is_driver_installed(this->uart_num_)) {
+    uart_driver_delete(this->uart_num_);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "uart_driver_delete failed: %s", esp_err_to_name(err));
+      this->mark_failed();
+      return;
+    }
+  }
   err = uart_driver_install(this->uart_num_, /* UART RX ring buffer size. */ this->rx_buffer_size_,
                             /* UART TX ring buffer size. If set to zero, driver will not use TX buffer, TX function will
                                block task until all data have been sent out.*/
@@ -133,17 +148,29 @@ void IDFUARTComponent::setup() {
     return;
   }
 
-  xSemaphoreGive(this->lock_);
-}
+  err = uart_set_rx_full_threshold(this->uart_num_, this->rx_full_threshold_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "uart_set_rx_full_threshold failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
 
-void IDFUARTComponent::load_settings(bool dump_config) {
-  uart_config_t uart_config = this->get_config_();
-  esp_err_t err = uart_param_config(this->uart_num_, &uart_config);
+  err = uart_set_rx_timeout(this->uart_num_, this->rx_timeout_);
   if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_param_config failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "uart_set_rx_timeout failed: %s", esp_err_to_name(err));
+    this->mark_failed();
+    return;
+  }
+
+  auto mode = this->flow_control_pin_ != nullptr ? UART_MODE_RS485_HALF_DUPLEX : UART_MODE_UART;
+  err = uart_set_mode(this->uart_num_, mode);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "uart_set_mode failed: %s", esp_err_to_name(err));
     this->mark_failed();
     return;
-  } else if (dump_config) {
+  }
+
+  if (dump_config) {
     ESP_LOGCONFIG(TAG, "UART %u was reloaded.", this->uart_num_);
     this->dump_config();
   }
@@ -153,8 +180,13 @@ void IDFUARTComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "UART Bus %u:", this->uart_num_);
   LOG_PIN("  TX Pin: ", tx_pin_);
   LOG_PIN("  RX Pin: ", rx_pin_);
+  LOG_PIN("  Flow Control Pin: ", flow_control_pin_);
   if (this->rx_pin_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  RX Buffer Size: %u", this->rx_buffer_size_);
+    ESP_LOGCONFIG(TAG,
+                  "  RX Buffer Size: %u\n"
+                  "  RX Full Threshold: %u\n"
+                  "  RX Timeout: %u",
+                  this->rx_buffer_size_, this->rx_full_threshold_, this->rx_timeout_);
   }
   ESP_LOGCONFIG(TAG,
                 "  Baud Rate: %" PRIu32 " baud\n"
@@ -165,6 +197,28 @@ void IDFUARTComponent::dump_config() {
   this->check_logger_conflict();
 }
 
+void IDFUARTComponent::set_rx_full_threshold(size_t rx_full_threshold) {
+  if (this->is_ready()) {
+    esp_err_t err = uart_set_rx_full_threshold(this->uart_num_, rx_full_threshold);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "uart_set_rx_full_threshold failed: %s", esp_err_to_name(err));
+      return;
+    }
+  }
+  this->rx_full_threshold_ = rx_full_threshold;
+}
+
+void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
+  if (this->is_ready()) {
+    esp_err_t err = uart_set_rx_timeout(this->uart_num_, rx_timeout);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "uart_set_rx_timeout failed: %s", esp_err_to_name(err));
+      return;
+    }
+  }
+  this->rx_timeout_ = rx_timeout;
+}
+
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
   xSemaphoreTake(this->lock_, portMAX_DELAY);
   uart_write_bytes(this->uart_num_, data, len);

esphome/components/uart/uart_component_esp_idf.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include <driver/uart.h>
 #include "esphome/core/component.h"
@@ -15,6 +15,9 @@ class IDFUARTComponent : public UARTComponent, public Component {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::BUS; }
 
+  void set_rx_full_threshold(size_t rx_full_threshold) override;
+  void set_rx_timeout(size_t rx_timeout) override;
+
   void write_array(const uint8_t *data, size_t len) override;
 
   bool peek_byte(uint8_t *data) override;
@@ -55,4 +58,4 @@ class IDFUARTComponent : public UARTComponent, public Component {
 }  // namespace uart
 }  // namespace esphome
 
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32

esphome/components/uponor_smatrix/climate/uponor_smatrix_climate.cpp

@@ -58,7 +58,7 @@ void UponorSmatrixClimate::control(const climate::ClimateCall &call) {
 }
 
 void UponorSmatrixClimate::on_device_data(const UponorSmatrixData *data, size_t data_len) {
-  for (int i = 0; i < data_len; i++) {
+  for (size_t i = 0; i < data_len; i++) {
     switch (data[i].id) {
       case UPONOR_ID_TARGET_TEMP_MIN:
         this->min_temperature_ = raw_to_celsius(data[i].value);

esphome/components/uponor_smatrix/sensor/uponor_smatrix_sensor.cpp

@@ -18,7 +18,7 @@ void UponorSmatrixSensor::dump_config() {
 }
 
 void UponorSmatrixSensor::on_device_data(const UponorSmatrixData *data, size_t data_len) {
-  for (int i = 0; i < data_len; i++) {
+  for (size_t i = 0; i < data_len; i++) {
     switch (data[i].id) {
       case UPONOR_ID_ROOM_TEMP:
         if (this->temperature_sensor_ != nullptr)