esphome 2025.5.1__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/usb_host/usb_host_component.cpp

@@ -0,0 +1,35 @@
+// Should not be needed, but it's required to pass CI clang-tidy checks
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "usb_host.h"
+#include <cinttypes>
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace usb_host {
+
+void USBHost::setup() {
+  ESP_LOGCONFIG(TAG, "Setup starts");
+  usb_host_config_t config{};
+
+  if (usb_host_install(&config) != ESP_OK) {
+    this->status_set_error("usb_host_install failed");
+    this->mark_failed();
+    return;
+  }
+}
+void USBHost::loop() {
+  int err;
+  uint32_t event_flags;
+  err = usb_host_lib_handle_events(0, &event_flags);
+  if (err != ESP_OK && err != ESP_ERR_TIMEOUT) {
+    ESP_LOGD(TAG, "lib_handle_events failed failed: %s", esp_err_to_name(err));
+  }
+  if (event_flags != 0) {
+    ESP_LOGD(TAG, "Event flags %" PRIu32 "X", event_flags);
+  }
+}
+
+}  // namespace usb_host
+}  // namespace esphome
+
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3

esphome/components/usb_uart/__init__.py

@@ -0,0 +1,134 @@
+import esphome.codegen as cg
+from esphome.components.uart import (
+    CONF_DATA_BITS,
+    CONF_PARITY,
+    CONF_STOP_BITS,
+    UARTComponent,
+)
+from esphome.components.usb_host import register_usb_client, usb_device_schema
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BAUD_RATE,
+    CONF_BUFFER_SIZE,
+    CONF_CHANNELS,
+    CONF_DEBUG,
+    CONF_DUMMY_RECEIVER,
+    CONF_ID,
+)
+from esphome.cpp_types import Component
+
+AUTO_LOAD = ["uart", "usb_host", "bytebuffer"]
+CODEOWNERS = ["@clydebarrow"]
+
+usb_uart_ns = cg.esphome_ns.namespace("usb_uart")
+USBUartComponent = usb_uart_ns.class_("USBUartComponent", Component)
+USBUartChannel = usb_uart_ns.class_("USBUartChannel", UARTComponent)
+
+
+UARTParityOptions = usb_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,
+    "MARK": UARTParityOptions.UART_CONFIG_PARITY_MARK,
+    "SPACE": UARTParityOptions.UART_CONFIG_PARITY_SPACE,
+}
+
+UARTStopBitsOptions = usb_uart_ns.enum("UARTStopBitsOptions")
+UART_STOP_BITS_OPTIONS = {
+    "1": UARTStopBitsOptions.UART_CONFIG_STOP_BITS_1,
+    "1.5": UARTStopBitsOptions.UART_CONFIG_STOP_BITS_1_5,
+    "2": UARTStopBitsOptions.UART_CONFIG_STOP_BITS_2,
+}
+
+DEFAULT_BAUD_RATE = 9600
+
+
+class Type:
+    def __init__(self, name, vid, pid, cls, max_channels=1, baud_rate_required=True):
+        self.name = name
+        cls = cls or name
+        self.vid = vid
+        self.pid = pid
+        self.cls = usb_uart_ns.class_(f"USBUartType{cls}", USBUartComponent)
+        self.max_channels = max_channels
+        self.baud_rate_required = baud_rate_required
+
+
+uart_types = (
+    Type("CH34X", 0x1A86, 0x55D5, "CH34X", 3),
+    Type("CH340", 0x1A86, 0x7523, "CH34X", 1),
+    Type("ESP_JTAG", 0x303A, 0x1001, "CdcAcm", 1, baud_rate_required=False),
+    Type("STM32_VCP", 0x0483, 0x5740, "CdcAcm", 1, baud_rate_required=False),
+    Type("CDC_ACM", 0, 0, "CdcAcm", 1, baud_rate_required=False),
+    Type("CP210X", 0x10C4, 0xEA60, "CP210X", 3),
+)
+
+
+def channel_schema(channels, baud_rate_required):
+    return cv.Schema(
+        {
+            cv.Required(CONF_CHANNELS): cv.All(
+                cv.ensure_list(
+                    cv.Schema(
+                        {
+                            cv.GenerateID(): cv.declare_id(USBUartChannel),
+                            cv.Optional(CONF_BUFFER_SIZE, default=256): cv.int_range(
+                                min=64, max=8192
+                            ),
+                            (
+                                cv.Required(CONF_BAUD_RATE)
+                                if baud_rate_required
+                                else cv.Optional(
+                                    CONF_BAUD_RATE, default=DEFAULT_BAUD_RATE
+                                )
+                            ): cv.int_range(min=300, max=1000000),
+                            cv.Optional(CONF_STOP_BITS, default="1"): cv.enum(
+                                UART_STOP_BITS_OPTIONS, upper=True
+                            ),
+                            cv.Optional(CONF_PARITY, default="NONE"): cv.enum(
+                                UART_PARITY_OPTIONS, upper=True
+                            ),
+                            cv.Optional(CONF_DATA_BITS, default=8): cv.int_range(
+                                min=5, max=8
+                            ),
+                            cv.Optional(CONF_DUMMY_RECEIVER, default=False): cv.boolean,
+                            cv.Optional(CONF_DEBUG, default=False): cv.boolean,
+                        }
+                    )
+                ),
+                cv.Length(max=channels),
+            )
+        }
+    )
+
+
+CONFIG_SCHEMA = cv.ensure_list(
+    cv.typed_schema(
+        {
+            it.name: usb_device_schema(it.cls, it.vid, it.pid).extend(
+                channel_schema(it.max_channels, it.baud_rate_required)
+            )
+            for it in uart_types
+        },
+        upper=True,
+    )
+)
+
+
+async def to_code(config):
+    for device in config:
+        var = await register_usb_client(device)
+        for index, channel in enumerate(device[CONF_CHANNELS]):
+            chvar = cg.new_Pvariable(channel[CONF_ID], index, channel[CONF_BUFFER_SIZE])
+            await cg.register_parented(chvar, var)
+            cg.add(chvar.set_rx_buffer_size(channel[CONF_BUFFER_SIZE]))
+            cg.add(chvar.set_stop_bits(channel[CONF_STOP_BITS]))
+            cg.add(chvar.set_data_bits(channel[CONF_DATA_BITS]))
+            cg.add(chvar.set_parity(channel[CONF_PARITY]))
+            cg.add(chvar.set_baud_rate(channel[CONF_BAUD_RATE]))
+            cg.add(chvar.set_dummy_receiver(channel[CONF_DUMMY_RECEIVER]))
+            cg.add(chvar.set_debug(channel[CONF_DEBUG]))
+            cg.add(var.add_channel(chvar))
+            if channel[CONF_DEBUG]:
+                cg.add_define("USE_UART_DEBUGGER")

esphome/components/usb_uart/ch34x.cpp

@@ -0,0 +1,80 @@
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "usb_uart.h"
+#include "usb/usb_host.h"
+#include "esphome/core/log.h"
+
+#include "esphome/components/bytebuffer/bytebuffer.h"
+
+namespace esphome {
+namespace usb_uart {
+
+using namespace bytebuffer;
+/**
+ * CH34x
+ */
+
+void USBUartTypeCH34X::enable_channels() {
+  // enable the channels
+  for (auto channel : this->channels_) {
+    if (!channel->initialised_)
+      continue;
+    usb_host::transfer_cb_t callback = [=](const usb_host::TransferStatus &status) {
+      if (!status.success) {
+        ESP_LOGE(TAG, "Control transfer failed, status=%s", esp_err_to_name(status.error_code));
+        channel->initialised_ = false;
+      }
+    };
+
+    uint8_t divisor = 7;
+    uint32_t clk = 12000000;
+
+    auto baud_rate = channel->baud_rate_;
+    if (baud_rate < 256000) {
+      if (baud_rate > 6000000 / 255) {
+        divisor = 3;
+        clk = 6000000;
+      } else if (baud_rate > 750000 / 255) {
+        divisor = 2;
+        clk = 750000;
+      } else if (baud_rate > 93750 / 255) {
+        divisor = 1;
+        clk = 93750;
+      } else {
+        divisor = 0;
+        clk = 11719;
+      }
+    }
+    ESP_LOGV(TAG, "baud_rate: %" PRIu32 ", divisor: %d, clk: %" PRIu32, baud_rate, divisor, clk);
+    auto factor = static_cast<uint8_t>(clk / baud_rate);
+    if (factor == 0 || factor == 0xFF) {
+      ESP_LOGE(TAG, "Invalid baud rate %" PRIu32, baud_rate);
+      channel->initialised_ = false;
+      continue;
+    }
+    if ((clk / factor - baud_rate) > (baud_rate - clk / (factor + 1)))
+      factor++;
+    factor = 256 - factor;
+
+    uint16_t value = 0xC0;
+    if (channel->stop_bits_ == UART_CONFIG_STOP_BITS_2)
+      value |= 4;
+    switch (channel->parity_) {
+      case UART_CONFIG_PARITY_NONE:
+        break;
+      default:
+        value |= 8 | ((channel->parity_ - 1) << 4);
+        break;
+    }
+    value |= channel->data_bits_ - 5;
+    value <<= 8;
+    value |= 0x8C;
+    uint8_t cmd = 0xA1 + channel->index_;
+    if (channel->index_ >= 2)
+      cmd += 0xE;
+    this->control_transfer(USB_VENDOR_DEV | usb_host::USB_DIR_OUT, cmd, value, (factor << 8) | divisor, callback);
+  }
+  USBUartTypeCdcAcm::enable_channels();
+}
+}  // namespace usb_uart
+}  // namespace esphome
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3

esphome/components/usb_uart/cp210x.cpp

@@ -0,0 +1,126 @@
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "usb_uart.h"
+#include "usb/usb_host.h"
+#include "esphome/core/log.h"
+
+#include "esphome/components/bytebuffer/bytebuffer.h"
+
+namespace esphome {
+namespace usb_uart {
+
+using namespace bytebuffer;
+/**
+ * Silabs CP210x Commands
+ */
+
+static constexpr uint8_t IFC_ENABLE = 0x00;       // Enable or disable the interface.
+static constexpr uint8_t SET_BAUDDIV = 0x01;      // Set the baud rate divisor.
+static constexpr uint8_t GET_BAUDDIV = 0x02;      // Get the baud rate divisor.
+static constexpr uint8_t SET_LINE_CTL = 0x03;     // Set the line control.
+static constexpr uint8_t GET_LINE_CTL = 0x04;     // Get the line control.
+static constexpr uint8_t SET_BREAK = 0x05;        // Set a BREAK.
+static constexpr uint8_t IMM_CHAR = 0x06;         // Send character out of order.
+static constexpr uint8_t SET_MHS = 0x07;          // Set modem handshaking.
+static constexpr uint8_t GET_MDMSTS = 0x08;       // Get modem status.
+static constexpr uint8_t SET_XON = 0x09;          // Emulate XON.
+static constexpr uint8_t SET_XOFF = 0x0A;         // Emulate XOFF.
+static constexpr uint8_t SET_EVENTMASK = 0x0B;    // Set the event mask.
+static constexpr uint8_t GET_EVENTMASK = 0x0C;    // Get the event mask.
+static constexpr uint8_t GET_EVENTSTATE = 0x16;   // Get the event state.
+static constexpr uint8_t SET_RECEIVE = 0x17;      // Set receiver max timeout.
+static constexpr uint8_t GET_RECEIVE = 0x18;      // Get receiver max timeout.
+static constexpr uint8_t SET_CHAR = 0x0D;         // Set special character individually.
+static constexpr uint8_t GET_CHARS = 0x0E;        // Get special characters.
+static constexpr uint8_t GET_PROPS = 0x0F;        // Get properties.
+static constexpr uint8_t GET_COMM_STATUS = 0x10;  // Get the serial status.
+static constexpr uint8_t RESET = 0x11;            // Reset.
+static constexpr uint8_t PURGE = 0x12;            // Purge.
+static constexpr uint8_t SET_FLOW = 0x13;         // Set flow control.
+static constexpr uint8_t GET_FLOW = 0x14;         // Get flow control.
+static constexpr uint8_t EMBED_EVENTS = 0x15;     // Control embedding of events in the data stream.
+static constexpr uint8_t GET_BAUDRATE = 0x1D;     // Get the baud rate.
+static constexpr uint8_t SET_BAUDRATE = 0x1E;     // Set the baud rate.
+static constexpr uint8_t SET_CHARS = 0x19;        // Set special characters.
+static constexpr uint8_t VENDOR_SPECIFIC = 0xFF;  // Vendor specific command.
+
+std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors_(usb_device_handle_t dev_hdl) {
+  const usb_config_desc_t *config_desc;
+  const usb_device_desc_t *device_desc;
+  int conf_offset = 0, ep_offset;
+  std::vector<CdcEps> cdc_devs{};
+
+  // Get required descriptors
+  if (usb_host_get_device_descriptor(dev_hdl, &device_desc) != ESP_OK) {
+    ESP_LOGE(TAG, "get_device_descriptor failed");
+    return {};
+  }
+  if (usb_host_get_active_config_descriptor(dev_hdl, &config_desc) != ESP_OK) {
+    ESP_LOGE(TAG, "get_active_config_descriptor failed");
+    return {};
+  }
+  ESP_LOGD(TAG, "bDeviceClass: %u, bDeviceSubClass: %u", device_desc->bDeviceClass, device_desc->bDeviceSubClass);
+  ESP_LOGD(TAG, "bNumInterfaces: %u", config_desc->bNumInterfaces);
+  if (device_desc->bDeviceClass != 0) {
+    ESP_LOGE(TAG, "bDeviceClass != 0");
+    return {};
+  }
+
+  for (uint8_t i = 0; i != config_desc->bNumInterfaces; i++) {
+    auto data_desc = usb_parse_interface_descriptor(config_desc, 0, 0, &conf_offset);
+    if (!data_desc) {
+      ESP_LOGE(TAG, "data_desc: usb_parse_interface_descriptor failed");
+      break;
+    }
+    if (data_desc->bNumEndpoints != 2 || data_desc->bInterfaceClass != USB_CLASS_VENDOR_SPEC) {
+      ESP_LOGE(TAG, "data_desc: bInterfaceClass == %u, bInterfaceSubClass == %u, bNumEndpoints == %u",
+               data_desc->bInterfaceClass, data_desc->bInterfaceSubClass, data_desc->bNumEndpoints);
+      continue;
+    }
+    ep_offset = conf_offset;
+    auto out_ep = usb_parse_endpoint_descriptor_by_index(data_desc, 0, config_desc->wTotalLength, &ep_offset);
+    if (!out_ep) {
+      ESP_LOGE(TAG, "out_ep: usb_parse_endpoint_descriptor_by_index failed");
+      continue;
+    }
+    ep_offset = conf_offset;
+    auto in_ep = usb_parse_endpoint_descriptor_by_index(data_desc, 1, config_desc->wTotalLength, &ep_offset);
+    if (!in_ep) {
+      ESP_LOGE(TAG, "in_ep: usb_parse_endpoint_descriptor_by_index failed");
+      continue;
+    }
+    if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN) {
+      cdc_devs.push_back({CdcEps{nullptr, in_ep, out_ep, data_desc->bInterfaceNumber}});
+    } else {
+      cdc_devs.push_back({CdcEps{nullptr, out_ep, in_ep, data_desc->bInterfaceNumber}});
+    }
+  }
+  return cdc_devs;
+}
+
+void USBUartTypeCP210X::enable_channels() {
+  // enable the channels
+  for (auto channel : this->channels_) {
+    if (!channel->initialised_)
+      continue;
+    usb_host::transfer_cb_t callback = [=](const usb_host::TransferStatus &status) {
+      if (!status.success) {
+        ESP_LOGE(TAG, "Control transfer failed, status=%s", esp_err_to_name(status.error_code));
+        channel->initialised_ = false;
+      }
+    };
+    this->control_transfer(USB_VENDOR_IFC | usb_host::USB_DIR_OUT, IFC_ENABLE, 1, channel->index_, callback);
+    uint16_t line_control = channel->stop_bits_;
+    line_control |= static_cast<uint8_t>(channel->parity_) << 4;
+    line_control |= channel->data_bits_ << 8;
+    ESP_LOGD(TAG, "Line control value 0x%X", line_control);
+    this->control_transfer(USB_VENDOR_IFC | usb_host::USB_DIR_OUT, SET_LINE_CTL, line_control, channel->index_,
+                           callback);
+    auto baud = ByteBuffer::wrap(channel->baud_rate_, LITTLE);
+    this->control_transfer(USB_VENDOR_IFC | usb_host::USB_DIR_OUT, SET_BAUDRATE, 0, channel->index_, callback,
+                           baud.get_data());
+  }
+  USBUartTypeCdcAcm::enable_channels();
+}
+}  // namespace usb_uart
+}  // namespace esphome
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3