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

esphome/components/usb_uart/usb_uart.cpp

@@ -0,0 +1,328 @@
+// 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_uart.h"
+#include "esphome/core/log.h"
+#include "esphome/components/uart/uart_debugger.h"
+
+#include <cinttypes>
+
+namespace esphome {
+namespace usb_uart {
+
+/**
+ *
+ * Given a configuration, look for the required interfaces defining a CDC-ACM device
+ * @param config_desc The configuration descriptor
+ * @param intf_idx The index of the interface to be examined
+ * @return
+ */
+static optional<CdcEps> get_cdc(const usb_config_desc_t *config_desc, uint8_t intf_idx) {
+  int conf_offset, ep_offset;
+  const usb_ep_desc_t *notify_ep{}, *in_ep{}, *out_ep{};
+  uint8_t interface_number = 0;
+  // look for an interface with one interrupt endpoint (notify), and an interface with two bulk endpoints (data in/out)
+  for (;;) {
+    auto intf_desc = usb_parse_interface_descriptor(config_desc, intf_idx++, 0, &conf_offset);
+    if (!intf_desc) {
+      ESP_LOGE(TAG, "usb_parse_interface_descriptor failed");
+      return nullopt;
+    }
+    if (intf_desc->bNumEndpoints == 1) {
+      ep_offset = conf_offset;
+      notify_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
+      if (!notify_ep) {
+        ESP_LOGE(TAG, "notify_ep: usb_parse_endpoint_descriptor_by_index failed");
+        return nullopt;
+      }
+      if (notify_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_INT)
+        notify_ep = nullptr;
+    } else if (USB_CLASS_CDC_DATA && intf_desc->bNumEndpoints == 2) {
+      interface_number = intf_desc->bInterfaceNumber;
+      ep_offset = conf_offset;
+      out_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 0, config_desc->wTotalLength, &ep_offset);
+      if (!out_ep) {
+        ESP_LOGE(TAG, "out_ep: usb_parse_endpoint_descriptor_by_index failed");
+        return nullopt;
+      }
+      if (out_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
+        out_ep = nullptr;
+      ep_offset = conf_offset;
+      in_ep = usb_parse_endpoint_descriptor_by_index(intf_desc, 1, config_desc->wTotalLength, &ep_offset);
+      if (!in_ep) {
+        ESP_LOGE(TAG, "in_ep: usb_parse_endpoint_descriptor_by_index failed");
+        return nullopt;
+      }
+      if (in_ep->bmAttributes != USB_BM_ATTRIBUTES_XFER_BULK)
+        in_ep = nullptr;
+    }
+    if (in_ep != nullptr && out_ep != nullptr && notify_ep != nullptr)
+      break;
+  }
+  if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN)
+    return CdcEps{notify_ep, in_ep, out_ep, interface_number};
+  return CdcEps{notify_ep, out_ep, in_ep, interface_number};
+}
+
+std::vector<CdcEps> USBUartTypeCdcAcm::parse_descriptors_(usb_device_handle_t dev_hdl) {
+  const usb_config_desc_t *config_desc;
+  const usb_device_desc_t *device_desc;
+  int desc_offset = 0;
+  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 {};
+  }
+  if (device_desc->bDeviceClass == USB_CLASS_COMM) {
+    // single CDC-ACM device
+    if (auto eps = get_cdc(config_desc, 0)) {
+      ESP_LOGV(TAG, "Found CDC-ACM device");
+      cdc_devs.push_back(*eps);
+    }
+    return cdc_devs;
+  }
+  if (((device_desc->bDeviceClass == USB_CLASS_MISC) && (device_desc->bDeviceSubClass == USB_SUBCLASS_COMMON) &&
+       (device_desc->bDeviceProtocol == USB_DEVICE_PROTOCOL_IAD)) ||
+      ((device_desc->bDeviceClass == USB_CLASS_PER_INTERFACE) && (device_desc->bDeviceSubClass == USB_SUBCLASS_NULL) &&
+       (device_desc->bDeviceProtocol == USB_PROTOCOL_NULL))) {
+    // This is a composite device, that uses Interface Association Descriptor
+    const auto *this_desc = reinterpret_cast<const usb_standard_desc_t *>(config_desc);
+    for (;;) {
+      this_desc = usb_parse_next_descriptor_of_type(this_desc, config_desc->wTotalLength,
+                                                    USB_B_DESCRIPTOR_TYPE_INTERFACE_ASSOCIATION, &desc_offset);
+      if (!this_desc)
+        break;
+      const auto *iad_desc = reinterpret_cast<const usb_iad_desc_t *>(this_desc);
+
+      if (iad_desc->bFunctionClass == USB_CLASS_COMM && iad_desc->bFunctionSubClass == USB_CDC_SUBCLASS_ACM) {
+        ESP_LOGV(TAG, "Found CDC-ACM device in composite device");
+        if (auto eps = get_cdc(config_desc, iad_desc->bFirstInterface))
+          cdc_devs.push_back(*eps);
+      }
+    }
+  }
+  return cdc_devs;
+}
+
+void RingBuffer::push(uint8_t item) {
+  this->buffer_[this->insert_pos_] = item;
+  this->insert_pos_ = (this->insert_pos_ + 1) % this->buffer_size_;
+}
+void RingBuffer::push(const uint8_t *data, size_t len) {
+  for (size_t i = 0; i != len; i++) {
+    this->buffer_[this->insert_pos_] = *data++;
+    this->insert_pos_ = (this->insert_pos_ + 1) % this->buffer_size_;
+  }
+}
+
+uint8_t RingBuffer::pop() {
+  uint8_t item = this->buffer_[this->read_pos_];
+  this->read_pos_ = (this->read_pos_ + 1) % this->buffer_size_;
+  return item;
+}
+size_t RingBuffer::pop(uint8_t *data, size_t len) {
+  len = std::min(len, this->get_available());
+  for (size_t i = 0; i != len; i++) {
+    *data++ = this->buffer_[this->read_pos_];
+    this->read_pos_ = (this->read_pos_ + 1) % this->buffer_size_;
+  }
+  return len;
+}
+void USBUartChannel::write_array(const uint8_t *data, size_t len) {
+  if (!this->initialised_) {
+    ESP_LOGV(TAG, "Channel not initialised - write ignored");
+    return;
+  }
+  while (this->output_buffer_.get_free_space() != 0 && len-- != 0) {
+    this->output_buffer_.push(*data++);
+  }
+  len++;
+  if (len > 0) {
+    ESP_LOGE(TAG, "Buffer full - failed to write %d bytes", len);
+  }
+  this->parent_->start_output(this);
+}
+
+bool USBUartChannel::peek_byte(uint8_t *data) {
+  if (this->input_buffer_.is_empty()) {
+    return false;
+  }
+  *data = this->input_buffer_.peek();
+  return true;
+}
+bool USBUartChannel::read_array(uint8_t *data, size_t len) {
+  if (!this->initialised_) {
+    ESP_LOGV(TAG, "Channel not initialised - read ignored");
+    return false;
+  }
+  auto available = this->available();
+  bool status = true;
+  if (len > available) {
+    ESP_LOGV(TAG, "underflow: requested %zu but returned %d, bytes", len, available);
+    len = available;
+    status = false;
+  }
+  for (size_t i = 0; i != len; i++) {
+    *data++ = this->input_buffer_.pop();
+  }
+  this->parent_->start_input(this);
+  return status;
+}
+void USBUartComponent::setup() { USBClient::setup(); }
+void USBUartComponent::loop() { USBClient::loop(); }
+void USBUartComponent::dump_config() {
+  USBClient::dump_config();
+  for (auto &channel : this->channels_) {
+    ESP_LOGCONFIG(TAG,
+                  "  UART Channel %d\n"
+                  "    Baud Rate: %" PRIu32 " baud\n"
+                  "    Data Bits: %u\n"
+                  "    Parity: %s\n"
+                  "    Stop bits: %s\n"
+                  "    Debug: %s\n"
+                  "    Dummy receiver: %s",
+                  channel->index_, channel->baud_rate_, channel->data_bits_, PARITY_NAMES[channel->parity_],
+                  STOP_BITS_NAMES[channel->stop_bits_], YESNO(channel->debug_), YESNO(channel->dummy_receiver_));
+  }
+}
+void USBUartComponent::start_input(USBUartChannel *channel) {
+  if (!channel->initialised_ || channel->input_started_ ||
+      channel->input_buffer_.get_free_space() < channel->cdc_dev_.in_ep->wMaxPacketSize)
+    return;
+  auto ep = channel->cdc_dev_.in_ep;
+  auto callback = [this, channel](const usb_host::TransferStatus &status) {
+    ESP_LOGV(TAG, "Transfer result: length: %u; status %X", status.data_len, status.error_code);
+    if (!status.success) {
+      ESP_LOGE(TAG, "Control transfer failed, status=%s", esp_err_to_name(status.error_code));
+      return;
+    }
+#ifdef USE_UART_DEBUGGER
+    if (channel->debug_) {
+      uart::UARTDebug::log_hex(uart::UART_DIRECTION_RX,
+                               std::vector<uint8_t>(status.data, status.data + status.data_len), ',');  // NOLINT()
+    }
+#endif
+    channel->input_started_ = false;
+    if (!channel->dummy_receiver_) {
+      for (size_t i = 0; i != status.data_len; i++) {
+        channel->input_buffer_.push(status.data[i]);
+      }
+    }
+    if (channel->input_buffer_.get_free_space() >= channel->cdc_dev_.in_ep->wMaxPacketSize) {
+      this->defer([this, channel] { this->start_input(channel); });
+    }
+  };
+  channel->input_started_ = true;
+  this->transfer_in(ep->bEndpointAddress, callback, ep->wMaxPacketSize);
+}
+
+void USBUartComponent::start_output(USBUartChannel *channel) {
+  if (channel->output_started_)
+    return;
+  if (channel->output_buffer_.is_empty()) {
+    return;
+  }
+  auto ep = channel->cdc_dev_.out_ep;
+  auto callback = [this, channel](const usb_host::TransferStatus &status) {
+    ESP_LOGV(TAG, "Output Transfer result: length: %u; status %X", status.data_len, status.error_code);
+    channel->output_started_ = false;
+    this->defer([this, channel] { this->start_output(channel); });
+  };
+  channel->output_started_ = true;
+  uint8_t data[ep->wMaxPacketSize];
+  auto len = channel->output_buffer_.pop(data, ep->wMaxPacketSize);
+  this->transfer_out(ep->bEndpointAddress, callback, data, len);
+#ifdef USE_UART_DEBUGGER
+  if (channel->debug_) {
+    uart::UARTDebug::log_hex(uart::UART_DIRECTION_TX, std::vector<uint8_t>(data, data + len), ',');  // NOLINT()
+  }
+#endif
+  ESP_LOGV(TAG, "Output %d bytes started", len);
+}
+
+/**
+ * Hacky fix for some devices that report incorrect MPS values
+ * @param ep The endpoint descriptor
+ */
+static void fix_mps(const usb_ep_desc_t *ep) {
+  if (ep != nullptr) {
+    auto *ep_mutable = const_cast<usb_ep_desc_t *>(ep);
+    if (ep->wMaxPacketSize > 64) {
+      ESP_LOGW(TAG, "Corrected MPS of EP %u from %u to 64", ep->bEndpointAddress, ep->wMaxPacketSize);
+      ep_mutable->wMaxPacketSize = 64;
+    }
+  }
+}
+void USBUartTypeCdcAcm::on_connected() {
+  auto cdc_devs = this->parse_descriptors_(this->device_handle_);
+  if (cdc_devs.empty()) {
+    this->status_set_error("No CDC-ACM device found");
+    this->disconnect();
+    return;
+  }
+  ESP_LOGD(TAG, "Found %zu CDC-ACM devices", cdc_devs.size());
+  auto i = 0;
+  for (auto channel : this->channels_) {
+    if (i == cdc_devs.size()) {
+      ESP_LOGE(TAG, "No configuration found for channel %d", channel->index_);
+      this->status_set_warning("No configuration found for channel");
+      break;
+    }
+    channel->cdc_dev_ = cdc_devs[i++];
+    fix_mps(channel->cdc_dev_.in_ep);
+    fix_mps(channel->cdc_dev_.out_ep);
+    channel->initialised_ = true;
+    auto err = usb_host_interface_claim(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number, 0);
+    if (err != ESP_OK) {
+      ESP_LOGE(TAG, "usb_host_interface_claim failed: %s, channel=%d, intf=%d", esp_err_to_name(err), channel->index_,
+               channel->cdc_dev_.interface_number);
+      this->status_set_error("usb_host_interface_claim failed");
+      this->disconnect();
+      return;
+    }
+  }
+  this->enable_channels();
+}
+
+void USBUartTypeCdcAcm::on_disconnected() {
+  for (auto channel : this->channels_) {
+    if (channel->cdc_dev_.in_ep != nullptr) {
+      usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
+      usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.in_ep->bEndpointAddress);
+    }
+    if (channel->cdc_dev_.out_ep != nullptr) {
+      usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
+      usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
+    }
+    if (channel->cdc_dev_.notify_ep != nullptr) {
+      usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
+      usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
+    }
+    usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.interface_number);
+    channel->initialised_ = false;
+    channel->input_started_ = false;
+    channel->output_started_ = false;
+    channel->input_buffer_.clear();
+    channel->output_buffer_.clear();
+  }
+  USBClient::on_disconnected();
+}
+
+void USBUartTypeCdcAcm::enable_channels() {
+  for (auto channel : this->channels_) {
+    if (!channel->initialised_)
+      continue;
+    channel->input_started_ = false;
+    channel->output_started_ = false;
+    this->start_input(channel);
+  }
+}
+
+}  // namespace usb_uart
+}  // namespace esphome
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3

esphome/components/usb_uart/usb_uart.h

@@ -0,0 +1,151 @@
+#pragma once
+
+#if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/uart/uart_component.h"
+#include "esphome/components/usb_host/usb_host.h"
+
+namespace esphome {
+namespace usb_uart {
+class USBUartTypeCdcAcm;
+class USBUartComponent;
+
+static const char *const TAG = "usb_uart";
+
+static constexpr uint8_t USB_CDC_SUBCLASS_ACM = 0x02;
+static constexpr uint8_t USB_SUBCLASS_COMMON = 0x02;
+static constexpr uint8_t USB_SUBCLASS_NULL = 0x00;
+static constexpr uint8_t USB_PROTOCOL_NULL = 0x00;
+static constexpr uint8_t USB_DEVICE_PROTOCOL_IAD = 0x01;
+static constexpr uint8_t USB_VENDOR_IFC = usb_host::USB_TYPE_VENDOR | usb_host::USB_RECIP_INTERFACE;
+static constexpr uint8_t USB_VENDOR_DEV = usb_host::USB_TYPE_VENDOR | usb_host::USB_RECIP_DEVICE;
+
+struct CdcEps {
+  const usb_ep_desc_t *notify_ep;
+  const usb_ep_desc_t *in_ep;
+  const usb_ep_desc_t *out_ep;
+  uint8_t interface_number;
+};
+
+enum UARTParityOptions {
+  UART_CONFIG_PARITY_NONE = 0,
+  UART_CONFIG_PARITY_ODD,
+  UART_CONFIG_PARITY_EVEN,
+  UART_CONFIG_PARITY_MARK,
+  UART_CONFIG_PARITY_SPACE,
+};
+
+enum UARTStopBitsOptions {
+  UART_CONFIG_STOP_BITS_1 = 0,
+  UART_CONFIG_STOP_BITS_1_5,
+  UART_CONFIG_STOP_BITS_2,
+};
+
+static const char *const PARITY_NAMES[] = {"NONE", "ODD", "EVEN", "MARK", "SPACE"};
+static const char *const STOP_BITS_NAMES[] = {"1", "1.5", "2"};
+
+class RingBuffer {
+ public:
+  RingBuffer(uint16_t buffer_size) : buffer_size_(buffer_size), buffer_(new uint8_t[buffer_size]) {}
+  bool is_empty() const { return this->read_pos_ == this->insert_pos_; }
+  size_t get_available() const {
+    return (this->insert_pos_ + this->buffer_size_ - this->read_pos_) % this->buffer_size_;
+  };
+  size_t get_free_space() const { return this->buffer_size_ - 1 - this->get_available(); }
+  uint8_t peek() const { return this->buffer_[this->read_pos_]; }
+  void push(uint8_t item);
+  void push(const uint8_t *data, size_t len);
+  uint8_t pop();
+  size_t pop(uint8_t *data, size_t len);
+  void clear() { this->read_pos_ = this->insert_pos_ = 0; }
+
+ protected:
+  uint16_t insert_pos_ = 0;
+  uint16_t read_pos_ = 0;
+  uint16_t buffer_size_;
+  uint8_t *buffer_;
+};
+
+class USBUartChannel : public uart::UARTComponent, public Parented<USBUartComponent> {
+  friend class USBUartComponent;
+  friend class USBUartTypeCdcAcm;
+  friend class USBUartTypeCP210X;
+  friend class USBUartTypeCH34X;
+
+ public:
+  USBUartChannel(uint8_t index, uint16_t buffer_size)
+      : index_(index), input_buffer_(RingBuffer(buffer_size)), output_buffer_(RingBuffer(buffer_size)) {}
+  void write_array(const uint8_t *data, size_t len) override;
+  ;
+  bool peek_byte(uint8_t *data) override;
+  ;
+  bool read_array(uint8_t *data, size_t len) override;
+  int available() override { return static_cast<int>(this->input_buffer_.get_available()); }
+  void flush() override {}
+  void check_logger_conflict() override {}
+  void set_parity(UARTParityOptions parity) { this->parity_ = parity; }
+  void set_debug(bool debug) { this->debug_ = debug; }
+  void set_dummy_receiver(bool dummy_receiver) { this->dummy_receiver_ = dummy_receiver; }
+
+ protected:
+  const uint8_t index_;
+  RingBuffer input_buffer_;
+  RingBuffer output_buffer_;
+  UARTParityOptions parity_{UART_CONFIG_PARITY_NONE};
+  bool input_started_{true};
+  bool output_started_{true};
+  CdcEps cdc_dev_{};
+  bool debug_{};
+  bool dummy_receiver_{};
+  bool initialised_{};
+};
+
+class USBUartComponent : public usb_host::USBClient {
+ public:
+  USBUartComponent(uint16_t vid, uint16_t pid) : usb_host::USBClient(vid, pid) {}
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  std::vector<USBUartChannel *> get_channels() { return this->channels_; }
+
+  void add_channel(USBUartChannel *channel) { this->channels_.push_back(channel); }
+
+  void start_input(USBUartChannel *channel);
+  void start_output(USBUartChannel *channel);
+
+ protected:
+  std::vector<USBUartChannel *> channels_{};
+};
+
+class USBUartTypeCdcAcm : public USBUartComponent {
+ public:
+  USBUartTypeCdcAcm(uint16_t vid, uint16_t pid) : USBUartComponent(vid, pid) {}
+
+ protected:
+  virtual std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl);
+  void on_connected() override;
+  virtual void enable_channels();
+  void on_disconnected() override;
+};
+
+class USBUartTypeCP210X : public USBUartTypeCdcAcm {
+ public:
+  USBUartTypeCP210X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {}
+
+ protected:
+  std::vector<CdcEps> parse_descriptors_(usb_device_handle_t dev_hdl) override;
+  void enable_channels() override;
+};
+class USBUartTypeCH34X : public USBUartTypeCdcAcm {
+ public:
+  USBUartTypeCH34X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {}
+
+ protected:
+  void enable_channels() override;
+};
+
+}  // namespace usb_uart
+}  // namespace esphome
+
+#endif  // USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3

esphome/components/valve/__init__.py

@@ -163,6 +163,7 @@ async def register_valve(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_valve(var))
+    CORE.register_platform_component("valve", var)
     await _setup_valve_core(var, config)
 
 

esphome/components/veml3235/veml3235.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "veml3235.sensor";
 void VEML3235Sensor::setup() {
   uint8_t device_id[] = {0, 0};
 
-  ESP_LOGCONFIG(TAG, "Setting up VEML3235 '%s'...", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
 
   if (!this->refresh_config_reg()) {
     ESP_LOGE(TAG, "Unable to write configuration");
@@ -212,18 +212,22 @@ void VEML3235Sensor::dump_config() {
   LOG_SENSOR("", "VEML3235", this);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication failed");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
   ESP_LOGCONFIG(TAG, "  Auto-gain enabled: %s", YESNO(this->auto_gain_));
   if (this->auto_gain_) {
-    ESP_LOGCONFIG(TAG, "  Auto-gain upper threshold: %f%%", this->auto_gain_threshold_high_ * 100.0);
-    ESP_LOGCONFIG(TAG, "  Auto-gain lower threshold: %f%%", this->auto_gain_threshold_low_ * 100.0);
-    ESP_LOGCONFIG(TAG, "  Values below will be used as initial values only");
-  }
-  ESP_LOGCONFIG(TAG, "  Digital gain: %uX", digital_gain);
-  ESP_LOGCONFIG(TAG, "  Gain: %uX", gain);
-  ESP_LOGCONFIG(TAG, "  Integration time: %ums", integration_time);
+    ESP_LOGCONFIG(TAG,
+                  "  Auto-gain upper threshold: %f%%\n"
+                  "  Auto-gain lower threshold: %f%%\n"
+                  "  Values below will be used as initial values only",
+                  this->auto_gain_threshold_high_ * 100.0, this->auto_gain_threshold_low_ * 100.0);
+  }
+  ESP_LOGCONFIG(TAG,
+                "  Digital gain: %uX\n"
+                "  Gain: %uX\n"
+                "  Integration time: %ums",
+                digital_gain, gain, integration_time);
 }
 
 }  // namespace veml3235

esphome/components/veml7700/veml7700.cpp

@@ -78,7 +78,7 @@ static const char *get_gain_str(Gain gain) {
 }
 
 void VEML7700Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up VEML7700/6030...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   auto err = this->configure_();
   if (err != i2c::ERROR_OK) {
@@ -93,11 +93,15 @@ void VEML7700Component::dump_config() {
   LOG_I2C_DEVICE(this);
   ESP_LOGCONFIG(TAG, "  Automatic gain/time: %s", YESNO(this->automatic_mode_enabled_));
   if (!this->automatic_mode_enabled_) {
-    ESP_LOGCONFIG(TAG, "  Gain: %s", get_gain_str(this->gain_));
-    ESP_LOGCONFIG(TAG, "  Integration time: %d ms", get_itime_ms(this->integration_time_));
+    ESP_LOGCONFIG(TAG,
+                  "  Gain: %s\n"
+                  "  Integration time: %d ms",
+                  get_gain_str(this->gain_), get_itime_ms(this->integration_time_));
   }
-  ESP_LOGCONFIG(TAG, "  Lux compensation: %s", YESNO(this->lux_compensation_enabled_));
-  ESP_LOGCONFIG(TAG, "  Glass attenuation factor: %f", this->glass_attenuation_factor_);
+  ESP_LOGCONFIG(TAG,
+                "  Lux compensation: %s\n"
+                "  Glass attenuation factor: %f",
+                YESNO(this->lux_compensation_enabled_), this->glass_attenuation_factor_);
   LOG_UPDATE_INTERVAL(this);
 
   LOG_SENSOR("  ", "ALS channel lux", this->ambient_light_sensor_);
@@ -109,7 +113,7 @@ void VEML7700Component::dump_config() {
   LOG_SENSOR("  ", "Actual integration time", this->actual_integration_time_sensor_);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with I2C VEML7700/6030 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/voice_assistant/voice_assistant.cpp

@@ -204,7 +204,7 @@ void VoiceAssistant::loop() {
       break;
     }
     case State::START_PIPELINE: {
-      ESP_LOGD(TAG, "Requesting start...");
+      ESP_LOGD(TAG, "Requesting start");
       uint32_t flags = 0;
       if (!this->continue_conversation_ && this->use_wake_word_)
         flags |= api::enums::VOICE_ASSISTANT_REQUEST_USE_WAKE_WORD;
@@ -223,7 +223,7 @@ void VoiceAssistant::loop() {
       msg.wake_word_phrase = this->wake_word_;
       this->wake_word_ = "";
 
-      if (this->api_client_ == nullptr || !this->api_client_->send_voice_assistant_request(msg)) {
+      if (this->api_client_ == nullptr || !this->api_client_->send_message(msg)) {
         ESP_LOGW(TAG, "Could not request start");
         this->error_trigger_->trigger("not-connected", "Could not request start");
         this->continuous_ = false;
@@ -245,7 +245,7 @@ void VoiceAssistant::loop() {
         if (this->audio_mode_ == AUDIO_MODE_API) {
           api::VoiceAssistantAudio msg;
           msg.data.assign((char *) this->send_buffer_, read_bytes);
-          this->api_client_->send_voice_assistant_audio(msg);
+          this->api_client_->send_message(msg);
         } else {
           if (!this->udp_socket_running_) {
             if (!this->start_udp_socket_()) {
@@ -331,7 +331,7 @@ void VoiceAssistant::loop() {
 
           api::VoiceAssistantAnnounceFinished msg;
           msg.success = true;
-          this->api_client_->send_voice_assistant_announce_finished(msg);
+          this->api_client_->send_message(msg);
           break;
         }
       }
@@ -577,10 +577,10 @@ void VoiceAssistant::signal_stop_() {
   if (this->api_client_ == nullptr) {
     return;
   }
-  ESP_LOGD(TAG, "Signaling stop...");
+  ESP_LOGD(TAG, "Signaling stop");
   api::VoiceAssistantRequest msg;
   msg.start = false;
-  this->api_client_->send_voice_assistant_request(msg);
+  this->api_client_->send_message(msg);
 }
 
 void VoiceAssistant::start_playback_timeout_() {
@@ -590,7 +590,7 @@ void VoiceAssistant::start_playback_timeout_() {
 
     api::VoiceAssistantAnnounceFinished msg;
     msg.success = true;
-    this->api_client_->send_voice_assistant_announce_finished(msg);
+    this->api_client_->send_message(msg);
   });
 }
 

esphome/components/wake_on_lan/wake_on_lan.cpp

@@ -30,7 +30,7 @@ void WakeOnLanButton::press_action() {
     ESP_LOGW(TAG, "Network not connected");
     return;
   }
-  ESP_LOGI(TAG, "Sending Wake-on-LAN Packet...");
+  ESP_LOGI(TAG, "Sending Wake-on-LAN Packet");
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
   struct sockaddr_storage saddr {};
   auto addr_len =

esphome/components/waveshare_epaper/waveshare_epaper.cpp

@@ -1,7 +1,7 @@
 #include "waveshare_epaper.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <cinttypes>
 #include <bitset>