esphome 2024.6.6__py3-none-any.whl → 2024.7.0__py3-none-any.whl

esphome/components/ota/ota_backend_arduino_esp32.cpp

@@ -1,14 +1,17 @@
 #ifdef USE_ESP32_FRAMEWORK_ARDUINO
 #include "esphome/core/defines.h"
+#include "esphome/core/log.h"
 
-#include "ota_backend_arduino_esp32.h"
 #include "ota_backend.h"
+#include "ota_backend_arduino_esp32.h"
 
 #include <Update.h>
 
 namespace esphome {
 namespace ota {
 
+static const char *const TAG = "ota.arduino_esp32";
+
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP32OTABackend>(); }
 
 OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
@@ -20,6 +23,9 @@ OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
   uint8_t error = Update.getError();
   if (error == UPDATE_ERROR_SIZE)
     return OTA_RESPONSE_ERROR_ESP32_NOT_ENOUGH_SPACE;
+
+  ESP_LOGE(TAG, "Begin error: %d", error);
+
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
@@ -27,16 +33,25 @@ void ArduinoESP32OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5
 
 OTAResponseTypes ArduinoESP32OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
-  if (written != len) {
-    return OTA_RESPONSE_ERROR_WRITING_FLASH;
+  if (written == len) {
+    return OTA_RESPONSE_OK;
   }
-  return OTA_RESPONSE_OK;
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "Write error: %d", error);
+
+  return OTA_RESPONSE_ERROR_WRITING_FLASH;
 }
 
 OTAResponseTypes ArduinoESP32OTABackend::end() {
-  if (!Update.end())
-    return OTA_RESPONSE_ERROR_UPDATE_END;
-  return OTA_RESPONSE_OK;
+  if (Update.end()) {
+    return OTA_RESPONSE_OK;
+  }
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "End error: %d", error);
+
+  return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 
 void ArduinoESP32OTABackend::abort() { Update.abort(); }

esphome/components/ota/ota_backend_arduino_esp8266.cpp

@@ -1,16 +1,19 @@
 #ifdef USE_ARDUINO
 #ifdef USE_ESP8266
-#include "ota_backend.h"
 #include "ota_backend_arduino_esp8266.h"
+#include "ota_backend.h"
 
-#include "esphome/core/defines.h"
 #include "esphome/components/esp8266/preferences.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
 
 #include <Updater.h>
 
 namespace esphome {
 namespace ota {
 
+static const char *const TAG = "ota.arduino_esp8266";
+
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP8266OTABackend>(); }
 
 OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
@@ -29,6 +32,9 @@ OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
     return OTA_RESPONSE_ERROR_WRONG_CURRENT_FLASH_CONFIG;
   if (error == UPDATE_ERROR_SPACE)
     return OTA_RESPONSE_ERROR_ESP8266_NOT_ENOUGH_SPACE;
+
+  ESP_LOGE(TAG, "Begin error: %d", error);
+
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
@@ -36,16 +42,25 @@ void ArduinoESP8266OTABackend::set_update_md5(const char *md5) { Update.setMD5(m
 
 OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
-  if (written != len) {
-    return OTA_RESPONSE_ERROR_WRITING_FLASH;
+  if (written == len) {
+    return OTA_RESPONSE_OK;
   }
-  return OTA_RESPONSE_OK;
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "Write error: %d", error);
+
+  return OTA_RESPONSE_ERROR_WRITING_FLASH;
 }
 
 OTAResponseTypes ArduinoESP8266OTABackend::end() {
-  if (!Update.end())
-    return OTA_RESPONSE_ERROR_UPDATE_END;
-  return OTA_RESPONSE_OK;
+  if (Update.end()) {
+    return OTA_RESPONSE_OK;
+  }
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "End error: %d", error);
+
+  return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 
 void ArduinoESP8266OTABackend::abort() {

esphome/components/ota/ota_backend_arduino_libretiny.cpp

@@ -1,14 +1,17 @@
 #ifdef USE_LIBRETINY
-#include "ota_backend.h"
 #include "ota_backend_arduino_libretiny.h"
+#include "ota_backend.h"
 
 #include "esphome/core/defines.h"
+#include "esphome/core/log.h"
 
 #include <Update.h>
 
 namespace esphome {
 namespace ota {
 
+static const char *const TAG = "ota.arduino_libretiny";
+
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoLibreTinyOTABackend>(); }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
@@ -20,6 +23,9 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
   uint8_t error = Update.getError();
   if (error == UPDATE_ERROR_SIZE)
     return OTA_RESPONSE_ERROR_ESP32_NOT_ENOUGH_SPACE;
+
+  ESP_LOGE(TAG, "Begin error: %d", error);
+
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
@@ -27,16 +33,25 @@ void ArduinoLibreTinyOTABackend::set_update_md5(const char *md5) { Update.setMD5
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
-  if (written != len) {
-    return OTA_RESPONSE_ERROR_WRITING_FLASH;
+  if (written == len) {
+    return OTA_RESPONSE_OK;
   }
-  return OTA_RESPONSE_OK;
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "Write error: %d", error);
+
+  return OTA_RESPONSE_ERROR_WRITING_FLASH;
 }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::end() {
-  if (!Update.end())
-    return OTA_RESPONSE_ERROR_UPDATE_END;
-  return OTA_RESPONSE_OK;
+  if (Update.end()) {
+    return OTA_RESPONSE_OK;
+  }
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "End error: %d", error);
+
+  return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 
 void ArduinoLibreTinyOTABackend::abort() { Update.abort(); }

esphome/components/ota/ota_backend_arduino_rp2040.cpp

@@ -1,16 +1,19 @@
 #ifdef USE_ARDUINO
 #ifdef USE_RP2040
-#include "ota_backend.h"
 #include "ota_backend_arduino_rp2040.h"
+#include "ota_backend.h"
 
 #include "esphome/components/rp2040/preferences.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/log.h"
 
 #include <Updater.h>
 
 namespace esphome {
 namespace ota {
 
+static const char *const TAG = "ota.arduino_rp2040";
+
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoRP2040OTABackend>(); }
 
 OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
@@ -29,6 +32,9 @@ OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
     return OTA_RESPONSE_ERROR_WRONG_CURRENT_FLASH_CONFIG;
   if (error == UPDATE_ERROR_SPACE)
     return OTA_RESPONSE_ERROR_RP2040_NOT_ENOUGH_SPACE;
+
+  ESP_LOGE(TAG, "Begin error: %d", error);
+
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
@@ -36,16 +42,25 @@ void ArduinoRP2040OTABackend::set_update_md5(const char *md5) { Update.setMD5(md
 
 OTAResponseTypes ArduinoRP2040OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
-  if (written != len) {
-    return OTA_RESPONSE_ERROR_WRITING_FLASH;
+  if (written == len) {
+    return OTA_RESPONSE_OK;
   }
-  return OTA_RESPONSE_OK;
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "Write error: %d", error);
+
+  return OTA_RESPONSE_ERROR_WRITING_FLASH;
 }
 
 OTAResponseTypes ArduinoRP2040OTABackend::end() {
-  if (!Update.end())
-    return OTA_RESPONSE_ERROR_UPDATE_END;
-  return OTA_RESPONSE_OK;
+  if (Update.end()) {
+    return OTA_RESPONSE_OK;
+  }
+
+  uint8_t error = Update.getError();
+  ESP_LOGE(TAG, "End error: %d", error);
+
+  return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 
 void ArduinoRP2040OTABackend::abort() {

esphome/components/pmsa003i/pmsa003i.cpp

@@ -13,6 +13,15 @@ void PMSA003IComponent::setup() {
   PM25AQIData data;
   bool successful_read = this->read_data_(&data);
 
+  if (!successful_read) {
+    for (int i = 0; i < 3; i++) {
+      successful_read = this->read_data_(&data);
+      if (successful_read) {
+        break;
+      }
+    }
+  }
+
   if (!successful_read) {
     this->mark_failed();
     return;

esphome/components/qspi_amoled/display.py

@@ -42,6 +42,14 @@ COLOR_ORDERS = {
 }
 DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
 
+
+def validate_dimension(value):
+    value = cv.positive_int(value)
+    if value % 2 != 0:
+        raise cv.Invalid("Width/height/offset must be divisible by 2")
+    return value
+
+
 CONFIG_SCHEMA = cv.All(
     display.FULL_DISPLAY_SCHEMA.extend(
         cv.Schema(
@@ -52,10 +60,14 @@ CONFIG_SCHEMA = cv.All(
                     cv.dimensions,
                     cv.Schema(
                         {
-                            cv.Required(CONF_WIDTH): cv.int_,
-                            cv.Required(CONF_HEIGHT): cv.int_,
-                            cv.Optional(CONF_OFFSET_HEIGHT, default=0): cv.int_,
-                            cv.Optional(CONF_OFFSET_WIDTH, default=0): cv.int_,
+                            cv.Required(CONF_WIDTH): validate_dimension,
+                            cv.Required(CONF_HEIGHT): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_HEIGHT, default=0
+                            ): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_WIDTH, default=0
+                            ): validate_dimension,
                         }
                     ),
                 ),

esphome/components/qspi_amoled/qspi_amoled.cpp

@@ -25,7 +25,23 @@ void QspiAmoLed::setup() {
 }
 
 void QspiAmoLed::update() {
+  if (!this->setup_complete_) {
+    return;
+  }
   this->do_update_();
+  // Start addresses and widths/heights must be divisible by 2 (CASET/RASET restriction in datasheet)
+  if (this->x_low_ % 2 == 1) {
+    this->x_low_--;
+  }
+  if (this->x_high_ % 2 == 0) {
+    this->x_high_++;
+  }
+  if (this->y_low_ % 2 == 1) {
+    this->y_low_--;
+  }
+  if (this->y_high_ % 2 == 0) {
+    this->y_high_++;
+  }
   int w = this->x_high_ - this->x_low_ + 1;
   int h = this->y_high_ - this->y_low_ + 1;
   this->draw_pixels_at(this->x_low_, this->y_low_, w, h, this->buffer_, this->color_mode_, display::COLOR_BITNESS_565,

esphome/components/qspi_amoled/qspi_amoled.h

@@ -65,13 +65,10 @@ class QspiAmoLed : public display::DisplayBuffer,
 
   void set_reset_pin(GPIOPin *reset_pin) { this->reset_pin_ = reset_pin; }
   void set_enable_pin(GPIOPin *enable_pin) { this->enable_pin_ = enable_pin; }
-  void set_width(uint16_t width) { this->width_ = width; }
   void set_dimensions(uint16_t width, uint16_t height) {
     this->width_ = width;
     this->height_ = height;
   }
-  int get_width() override { return this->width_; }
-  int get_height() override { return this->height_; }
   void set_invert_colors(bool invert_colors) {
     this->invert_colors_ = invert_colors;
     this->reset_params_();

esphome/components/remote_base/dooya_protocol.cpp

@@ -8,10 +8,10 @@ static const char *const TAG = "remote.dooya";
 
 static const uint32_t HEADER_HIGH_US = 5000;
 static const uint32_t HEADER_LOW_US = 1500;
-static const uint32_t BIT_ZERO_HIGH_US = 750;
-static const uint32_t BIT_ZERO_LOW_US = 350;
-static const uint32_t BIT_ONE_HIGH_US = 350;
-static const uint32_t BIT_ONE_LOW_US = 750;
+static const uint32_t BIT_ZERO_HIGH_US = 350;
+static const uint32_t BIT_ZERO_LOW_US = 750;
+static const uint32_t BIT_ONE_HIGH_US = 750;
+static const uint32_t BIT_ONE_LOW_US = 350;
 
 void DooyaProtocol::encode(RemoteTransmitData *dst, const DooyaData &data) {
   dst->set_carrier_frequency(0);

esphome/components/remote_base/rc_switch_protocol.cpp

@@ -54,7 +54,7 @@ void RCSwitchBase::sync(RemoteTransmitData *dst) const {
   }
 }
 void RCSwitchBase::transmit(RemoteTransmitData *dst, uint64_t code, uint8_t len) const {
-  dst->set_carrier_frequency(0);
+  dst->set_carrier_frequency(38000);
   this->sync(dst);
   for (int16_t i = len - 1; i >= 0; i--) {
     if (code & ((uint64_t) 1 << i)) {

esphome/components/restart/button/__init__.py

@@ -5,6 +5,7 @@ from esphome.const import (
     CONF_ID,
     DEVICE_CLASS_RESTART,
     ENTITY_CATEGORY_CONFIG,
+    ICON_RESTART,
 )
 
 restart_ns = cg.esphome_ns.namespace("restart")
@@ -12,6 +13,7 @@ RestartButton = restart_ns.class_("RestartButton", button.Button, cg.Component)
 
 CONFIG_SCHEMA = button.button_schema(
     RestartButton,
+    icon=ICON_RESTART,
     device_class=DEVICE_CLASS_RESTART,
     entity_category=ENTITY_CATEGORY_CONFIG,
 ).extend(cv.COMPONENT_SCHEMA)

esphome/components/script/__init__.py

@@ -88,7 +88,7 @@ def validate_parameter_name(value):
     raise cv.Invalid(f"Script's parameter name cannot be {CONF_ID}")
 
 
-ALLOWED_PARAM_TYPE_CHARSET = set("abcdefghijklmnopqrstuvwxyz0123456789_:*&[]")
+ALLOWED_PARAM_TYPE_CHARSET = set("abcdefghijklmnopqrstuvwxyz0123456789_:*&[]<>")
 
 
 def validate_parameter_type(value):

esphome/components/sensor/__init__.py

@@ -43,6 +43,7 @@ from esphome.const import (
     DEVICE_CLASS_BATTERY,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
+    DEVICE_CLASS_CONDUCTIVITY,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_DATA_RATE,
     DEVICE_CLASS_DATA_SIZE,
@@ -103,6 +104,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_BATTERY,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
+    DEVICE_CLASS_CONDUCTIVITY,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_DATA_RATE,
     DEVICE_CLASS_DATA_SIZE,

esphome/components/tuya/tuya.cpp

@@ -223,13 +223,19 @@ void Tuya::handle_command_(uint8_t command, uint8_t version, const uint8_t *buff
       break;
     case TuyaCommandType::DATAPOINT_DELIVER:
       break;
-    case TuyaCommandType::DATAPOINT_REPORT:
+    case TuyaCommandType::DATAPOINT_REPORT_ASYNC:
+    case TuyaCommandType::DATAPOINT_REPORT_SYNC:
       if (this->init_state_ == TuyaInitState::INIT_DATAPOINT) {
         this->init_state_ = TuyaInitState::INIT_DONE;
         this->set_timeout("datapoint_dump", 1000, [this] { this->dump_config(); });
         this->initialized_callback_.call();
       }
       this->handle_datapoints_(buffer, len);
+
+      if (command_type == TuyaCommandType::DATAPOINT_REPORT_SYNC) {
+        this->send_command_(
+            TuyaCommand{.cmd = TuyaCommandType::DATAPOINT_REPORT_ACK, .payload = std::vector<uint8_t>{0x01}});
+      }
       break;
     case TuyaCommandType::DATAPOINT_QUERY:
       break;
@@ -423,7 +429,7 @@ void Tuya::send_raw_command_(TuyaCommand command) {
       break;
     case TuyaCommandType::DATAPOINT_DELIVER:
     case TuyaCommandType::DATAPOINT_QUERY:
-      this->expected_response_ = TuyaCommandType::DATAPOINT_REPORT;
+      this->expected_response_ = TuyaCommandType::DATAPOINT_REPORT_ASYNC;
       break;
     default:
       break;

esphome/components/tuya/tuya.h

@@ -53,10 +53,12 @@ enum class TuyaCommandType : uint8_t {
   WIFI_RESET = 0x04,
   WIFI_SELECT = 0x05,
   DATAPOINT_DELIVER = 0x06,
-  DATAPOINT_REPORT = 0x07,
+  DATAPOINT_REPORT_ASYNC = 0x07,
   DATAPOINT_QUERY = 0x08,
   WIFI_TEST = 0x0E,
   LOCAL_TIME_QUERY = 0x1C,
+  DATAPOINT_REPORT_SYNC = 0x22,
+  DATAPOINT_REPORT_ACK = 0x23,
   WIFI_RSSI = 0x24,
   VACUUM_MAP_UPLOAD = 0x28,
   GET_NETWORK_STATUS = 0x2B,

esphome/components/uart/__init__.py

@@ -1,5 +1,5 @@
 from typing import Optional
-
+import re
 import esphome.codegen as cg
 import esphome.config_validation as cv
 import esphome.final_validate as fv
@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_NUMBER,
     CONF_RX_PIN,
     CONF_TX_PIN,
+    CONF_PORT,
     CONF_UART_ID,
     CONF_DATA,
     CONF_RX_BUFFER_SIZE,
@@ -27,6 +28,7 @@ from esphome.const import (
     CONF_DUMMY_RECEIVER,
     CONF_DUMMY_RECEIVER_ID,
     CONF_LAMBDA,
+    PLATFORM_HOST,
 )
 from esphome.core import CORE
 
@@ -45,6 +47,7 @@ RP2040UartComponent = uart_ns.class_("RP2040UartComponent", UARTComponent, cg.Co
 LibreTinyUARTComponent = uart_ns.class_(
     "LibreTinyUARTComponent", UARTComponent, cg.Component
 )
+HostUartComponent = uart_ns.class_("HostUartComponent", UARTComponent, cg.Component)
 
 NATIVE_UART_CLASSES = (
     str(IDFUARTComponent),
@@ -54,6 +57,39 @@ NATIVE_UART_CLASSES = (
     str(LibreTinyUARTComponent),
 )
 
+HOST_BAUD_RATES = [
+    50,
+    75,
+    110,
+    134,
+    150,
+    200,
+    300,
+    600,
+    1200,
+    1800,
+    2400,
+    4800,
+    9600,
+    19200,
+    38400,
+    57600,
+    115200,
+    230400,
+    460800,
+    500000,
+    576000,
+    921600,
+    1000000,
+    1152000,
+    1500000,
+    2000000,
+    2500000,
+    3000000,
+    3500000,
+    4000000,
+]
+
 UARTDevice = uart_ns.class_("UARTDevice")
 UARTWriteAction = uart_ns.class_("UARTWriteAction", automation.Action)
 UARTDebugger = uart_ns.class_("UARTDebugger", cg.Component, automation.Action)
@@ -95,6 +131,20 @@ def validate_invert_esp32(config):
     return config
 
 
+def validate_host_config(config):
+    if CORE.is_host:
+        if CONF_TX_PIN in config or CONF_RX_PIN in config:
+            raise cv.Invalid(
+                "TX and RX pins are not supported for UART on host platform."
+            )
+        if config[CONF_BAUD_RATE] not in HOST_BAUD_RATES:
+            raise cv.Invalid(
+                f"Host platform doesn't support baud rate {config[CONF_BAUD_RATE]}",
+                path=[CONF_BAUD_RATE],
+            )
+    return config
+
+
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -107,6 +157,8 @@ def _uart_declare_type(value):
         return cv.declare_id(RP2040UartComponent)(value)
     if CORE.is_libretiny:
         return cv.declare_id(LibreTinyUARTComponent)(value)
+    if CORE.is_host:
+        return cv.declare_id(HostUartComponent)(value)
     raise NotImplementedError
 
 
@@ -149,6 +201,12 @@ def maybe_empty_debug(value):
     return DEBUG_SCHEMA(value)
 
 
+def validate_port(value):
+    if not re.match(r"^/(?:[^/]+/)[^/]+$", value):
+        raise cv.Invalid("Port must be a valid device path")
+    return value
+
+
 DEBUG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(UARTDebugger),
@@ -181,6 +239,7 @@ 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_PORT): cv.All(validate_port, cv.only_on(PLATFORM_HOST)),
             cv.Optional(CONF_RX_BUFFER_SIZE, default=256): cv.validate_bytes,
             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),
@@ -193,8 +252,9 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_DEBUG): maybe_empty_debug,
         }
     ).extend(cv.COMPONENT_SCHEMA),
-    cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN),
+    cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
     validate_invert_esp32,
+    validate_host_config,
 )
 
 
@@ -236,6 +296,8 @@ 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_PORT in config:
+        cg.add(var.set_name(config[CONF_PORT]))
     cg.add(var.set_rx_buffer_size(config[CONF_RX_BUFFER_SIZE]))
     cg.add(var.set_stop_bits(config[CONF_STOP_BITS]))
     cg.add(var.set_data_bits(config[CONF_DATA_BITS]))
@@ -258,6 +320,7 @@ KEY_UART_DEVICES = "uart_devices"
 def final_validate_device_schema(
     name: str,
     *,
+    uart_bus: str = CONF_UART_ID,
     baud_rate: Optional[int] = None,
     require_tx: bool = False,
     require_rx: bool = False,
@@ -268,7 +331,7 @@ def final_validate_device_schema(
     def validate_baud_rate(value):
         if value != baud_rate:
             raise cv.Invalid(
-                f"Component {name} requires baud rate {baud_rate} for the uart bus"
+                f"Component {name} requires baud rate {baud_rate} for the uart referenced by {uart_bus}"
             )
         return value
 
@@ -287,21 +350,21 @@ def final_validate_device_schema(
     def validate_data_bits(value):
         if value != data_bits:
             raise cv.Invalid(
-                f"Component {name} requires {data_bits} data bits for the uart bus"
+                f"Component {name} requires {data_bits} data bits for the uart referenced by {uart_bus}"
             )
         return value
 
     def validate_parity(value):
         if value != parity:
             raise cv.Invalid(
-                f"Component {name} requires parity {parity} for the uart bus"
+                f"Component {name} requires parity {parity} for the uart referenced by {uart_bus}"
             )
         return value
 
     def validate_stop_bits(value):
         if value != stop_bits:
             raise cv.Invalid(
-                f"Component {name} requires {stop_bits} stop bits for the uart bus"
+                f"Component {name} requires {stop_bits} stop bits for the uart referenced by {uart_bus}"
             )
         return value
 
@@ -316,14 +379,14 @@ def final_validate_device_schema(
             hub_schema[
                 cv.Required(
                     CONF_TX_PIN,
-                    msg=f"Component {name} requires this uart bus to declare a tx_pin",
+                    msg=f"Component {name} requires uart referenced by {uart_bus} to declare a tx_pin",
                 )
             ] = validate_pin(CONF_TX_PIN, device)
         if require_rx and uart_id_type_str in NATIVE_UART_CLASSES:
             hub_schema[
                 cv.Required(
                     CONF_RX_PIN,
-                    msg=f"Component {name} requires this uart bus to declare a rx_pin",
+                    msg=f"Component {name} requires uart referenced by {uart_bus} to declare a rx_pin",
                 )
             ] = validate_pin(CONF_RX_PIN, device)
         if baud_rate is not None:
@@ -337,7 +400,7 @@ def final_validate_device_schema(
         return cv.Schema(hub_schema, extra=cv.ALLOW_EXTRA)(hub_config)
 
     return cv.Schema(
-        {cv.Required(CONF_UART_ID): fv.id_declaration_match_schema(validate_hub)},
+        {cv.Required(uart_bus): fv.id_declaration_match_schema(validate_hub)},
         extra=cv.ALLOW_EXTRA,
     )