Check read_array return value in drain_rx_buffer_

Replace byte-at-a-time read() calls with batched read_array() in all
four UART read sites: receive_telegram_(), receive_encrypted_telegram_(),
and two drain loops. Each read() internally chains through
read_array(data, 1) -> check_read_timeout_(1) -> available(), resulting
in ~3 UART driver calls per byte. Batching into a 64-byte stack buffer
reduces this to ~3 calls per batch regardless of byte count.

Extract drain_rx_buffer_() helper to deduplicate the two drain sites
in ready_to_request_data_() and stop_requesting_data_().

esphome/components/dfplayer/dfplayer.cpp

@@ -1,5 +1,4 @@
 #include "dfplayer.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -133,151 +132,139 @@ void DFPlayer::send_cmd_(uint8_t cmd, uint16_t argument) {
 
 void DFPlayer::loop() {
   // Read message
-  int avail = this->available();
-  if (avail <= 0)
-    return;
+  while (this->available()) {
+    uint8_t byte;
+    this->read_byte(&byte);
 
-  uint8_t buf[64];
-  while (avail > 0) {
-    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
-    if (!this->read_array(buf, to_read)) {
-      break;
-    }
-    avail -= to_read;
-    for (size_t bi = 0; bi < to_read; bi++) {
-      uint8_t byte = buf[bi];
+    if (this->read_pos_ == DFPLAYER_READ_BUFFER_LENGTH)
+      this->read_pos_ = 0;
 
-      if (this->read_pos_ == DFPLAYER_READ_BUFFER_LENGTH)
-        this->read_pos_ = 0;
-
-      switch (this->read_pos_) {
-        case 0:  // Start mark
-          if (byte != 0x7E)
-            continue;
-          break;
-        case 1:  // Version
-          if (byte != 0xFF) {
-            ESP_LOGW(TAG, "Expected Version 0xFF, got %#02x", byte);
-            this->read_pos_ = 0;
-            continue;
-          }
-          break;
-        case 2:  // Buffer length
-          if (byte != 0x06) {
-            ESP_LOGW(TAG, "Expected Buffer length 0x06, got %#02x", byte);
-            this->read_pos_ = 0;
-            continue;
-          }
-          break;
-        case 9:  // End byte
-#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-          char byte_sequence[100];
-          byte_sequence[0] = '\0';
-          for (size_t i = 0; i < this->read_pos_ + 1; ++i) {
-            snprintf(byte_sequence + strlen(byte_sequence), sizeof(byte_sequence) - strlen(byte_sequence), "%02X ",
-                     this->read_buffer_[i]);
-          }
-          ESP_LOGVV(TAG, "Received byte sequence: %s", byte_sequence);
-#endif
-          if (byte != 0xEF) {
-            ESP_LOGW(TAG, "Expected end byte 0xEF, got %#02x", byte);
-            this->read_pos_ = 0;
-            continue;
-          }
-          // Parse valid received command
-          uint8_t cmd = this->read_buffer_[3];
-          uint16_t argument = (this->read_buffer_[5] << 8) | this->read_buffer_[6];
-
-          ESP_LOGV(TAG, "Received message cmd: %#02x arg %#04x", cmd, argument);
-
-          switch (cmd) {
-            case 0x3A:
-              if (argument == 1) {
-                ESP_LOGI(TAG, "USB loaded");
-              } else if (argument == 2) {
-                ESP_LOGI(TAG, "TF Card loaded");
-              }
-              break;
-            case 0x3B:
-              if (argument == 1) {
-                ESP_LOGI(TAG, "USB unloaded");
-              } else if (argument == 2) {
-                ESP_LOGI(TAG, "TF Card unloaded");
-              }
-              break;
-            case 0x3F:
-              if (argument == 1) {
-                ESP_LOGI(TAG, "USB available");
-              } else if (argument == 2) {
-                ESP_LOGI(TAG, "TF Card available");
-              } else if (argument == 3) {
-                ESP_LOGI(TAG, "USB, TF Card available");
-              }
-              break;
-            case 0x40:
-              ESP_LOGV(TAG, "Nack");
-              this->ack_set_is_playing_ = false;
-              this->ack_reset_is_playing_ = false;
-              switch (argument) {
-                case 0x01:
-                  ESP_LOGE(TAG, "Module is busy or uninitialized");
-                  break;
-                case 0x02:
-                  ESP_LOGE(TAG, "Module is in sleep mode");
-                  break;
-                case 0x03:
-                  ESP_LOGE(TAG, "Serial receive error");
-                  break;
-                case 0x04:
-                  ESP_LOGE(TAG, "Checksum incorrect");
-                  break;
-                case 0x05:
-                  ESP_LOGE(TAG, "Specified track is out of current track scope");
-                  this->is_playing_ = false;
-                  break;
-                case 0x06:
-                  ESP_LOGE(TAG, "Specified track is not found");
-                  this->is_playing_ = false;
-                  break;
-                case 0x07:
-                  ESP_LOGE(TAG,
-                           "Insertion error (an inserting operation only can be done when a track is being played)");
-                  break;
-                case 0x08:
-                  ESP_LOGE(TAG, "SD card reading failed (SD card pulled out or damaged)");
-                  break;
-                case 0x09:
-                  ESP_LOGE(TAG, "Entered into sleep mode");
-                  this->is_playing_ = false;
-                  break;
-              }
-              break;
-            case 0x41:
-              ESP_LOGV(TAG, "Ack ok");
-              this->is_playing_ |= this->ack_set_is_playing_;
-              this->is_playing_ &= !this->ack_reset_is_playing_;
-              this->ack_set_is_playing_ = false;
-              this->ack_reset_is_playing_ = false;
-              break;
-            case 0x3C:
-              ESP_LOGV(TAG, "Playback finished (USB drive)");
-              this->is_playing_ = false;
-              this->on_finished_playback_callback_.call();
-            case 0x3D:
-              ESP_LOGV(TAG, "Playback finished (SD card)");
-              this->is_playing_ = false;
-              this->on_finished_playback_callback_.call();
-              break;
-            default:
-              ESP_LOGE(TAG, "Received unknown cmd %#02x arg %#04x", cmd, argument);
-          }
-          this->sent_cmd_ = 0;
+    switch (this->read_pos_) {
+      case 0:  // Start mark
+        if (byte != 0x7E)
+          continue;
+        break;
+      case 1:  // Version
+        if (byte != 0xFF) {
+          ESP_LOGW(TAG, "Expected Version 0xFF, got %#02x", byte);
           this->read_pos_ = 0;
           continue;
-      }
-      this->read_buffer_[this->read_pos_] = byte;
-      this->read_pos_++;
+        }
+        break;
+      case 2:  // Buffer length
+        if (byte != 0x06) {
+          ESP_LOGW(TAG, "Expected Buffer length 0x06, got %#02x", byte);
+          this->read_pos_ = 0;
+          continue;
+        }
+        break;
+      case 9:  // End byte
+#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
+        char byte_sequence[100];
+        byte_sequence[0] = '\0';
+        for (size_t i = 0; i < this->read_pos_ + 1; ++i) {
+          snprintf(byte_sequence + strlen(byte_sequence), sizeof(byte_sequence) - strlen(byte_sequence), "%02X ",
+                   this->read_buffer_[i]);
+        }
+        ESP_LOGVV(TAG, "Received byte sequence: %s", byte_sequence);
+#endif
+        if (byte != 0xEF) {
+          ESP_LOGW(TAG, "Expected end byte 0xEF, got %#02x", byte);
+          this->read_pos_ = 0;
+          continue;
+        }
+        // Parse valid received command
+        uint8_t cmd = this->read_buffer_[3];
+        uint16_t argument = (this->read_buffer_[5] << 8) | this->read_buffer_[6];
+
+        ESP_LOGV(TAG, "Received message cmd: %#02x arg %#04x", cmd, argument);
+
+        switch (cmd) {
+          case 0x3A:
+            if (argument == 1) {
+              ESP_LOGI(TAG, "USB loaded");
+            } else if (argument == 2) {
+              ESP_LOGI(TAG, "TF Card loaded");
+            }
+            break;
+          case 0x3B:
+            if (argument == 1) {
+              ESP_LOGI(TAG, "USB unloaded");
+            } else if (argument == 2) {
+              ESP_LOGI(TAG, "TF Card unloaded");
+            }
+            break;
+          case 0x3F:
+            if (argument == 1) {
+              ESP_LOGI(TAG, "USB available");
+            } else if (argument == 2) {
+              ESP_LOGI(TAG, "TF Card available");
+            } else if (argument == 3) {
+              ESP_LOGI(TAG, "USB, TF Card available");
+            }
+            break;
+          case 0x40:
+            ESP_LOGV(TAG, "Nack");
+            this->ack_set_is_playing_ = false;
+            this->ack_reset_is_playing_ = false;
+            switch (argument) {
+              case 0x01:
+                ESP_LOGE(TAG, "Module is busy or uninitialized");
+                break;
+              case 0x02:
+                ESP_LOGE(TAG, "Module is in sleep mode");
+                break;
+              case 0x03:
+                ESP_LOGE(TAG, "Serial receive error");
+                break;
+              case 0x04:
+                ESP_LOGE(TAG, "Checksum incorrect");
+                break;
+              case 0x05:
+                ESP_LOGE(TAG, "Specified track is out of current track scope");
+                this->is_playing_ = false;
+                break;
+              case 0x06:
+                ESP_LOGE(TAG, "Specified track is not found");
+                this->is_playing_ = false;
+                break;
+              case 0x07:
+                ESP_LOGE(TAG, "Insertion error (an inserting operation only can be done when a track is being played)");
+                break;
+              case 0x08:
+                ESP_LOGE(TAG, "SD card reading failed (SD card pulled out or damaged)");
+                break;
+              case 0x09:
+                ESP_LOGE(TAG, "Entered into sleep mode");
+                this->is_playing_ = false;
+                break;
+            }
+            break;
+          case 0x41:
+            ESP_LOGV(TAG, "Ack ok");
+            this->is_playing_ |= this->ack_set_is_playing_;
+            this->is_playing_ &= !this->ack_reset_is_playing_;
+            this->ack_set_is_playing_ = false;
+            this->ack_reset_is_playing_ = false;
+            break;
+          case 0x3C:
+            ESP_LOGV(TAG, "Playback finished (USB drive)");
+            this->is_playing_ = false;
+            this->on_finished_playback_callback_.call();
+          case 0x3D:
+            ESP_LOGV(TAG, "Playback finished (SD card)");
+            this->is_playing_ = false;
+            this->on_finished_playback_callback_.call();
+            break;
+          default:
+            ESP_LOGE(TAG, "Received unknown cmd %#02x arg %#04x", cmd, argument);
+        }
+        this->sent_cmd_ = 0;
+        this->read_pos_ = 0;
+        continue;
     }
+    this->read_buffer_[this->read_pos_] = byte;
+    this->read_pos_++;
   }
 }
 void DFPlayer::dump_config() {

esphome/components/dsmr/dsmr.cpp

@@ -40,9 +40,7 @@ bool Dsmr::ready_to_request_data_() {
       this->start_requesting_data_();
     }
     if (!this->requesting_data_) {
-      while (this->available()) {
-        this->read();
-      }
+      this->drain_rx_buffer_();
     }
   }
   return this->requesting_data_;
@@ -115,13 +113,21 @@ void Dsmr::stop_requesting_data_() {
     } else {
       ESP_LOGV(TAG, "Stop reading data from P1 port");
     }
-    while (this->available()) {
-      this->read();
-    }
+    this->drain_rx_buffer_();
     this->requesting_data_ = false;
   }
 }
 
+void Dsmr::drain_rx_buffer_() {
+  uint8_t buf[64];
+  int avail;
+  while ((avail = this->available()) > 0) {
+    if (!this->read_array(buf, std::min(static_cast<size_t>(avail), sizeof(buf)))) {
+      break;
+    }
+  }
+}
+
 void Dsmr::reset_telegram_() {
   this->header_found_ = false;
   this->footer_found_ = false;
@@ -133,120 +139,144 @@ void Dsmr::reset_telegram_() {
 
 void Dsmr::receive_telegram_() {
   while (this->available_within_timeout_()) {
-    const char c = this->read();
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    int avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+      if (!this->read_array(buf, to_read))
+        return;
+      avail -= to_read;
 
-    // Find a new telegram header, i.e. forward slash.
-    if (c == '/') {
-      ESP_LOGV(TAG, "Header of telegram found");
-      this->reset_telegram_();
-      this->header_found_ = true;
-    }
-    if (!this->header_found_)
-      continue;
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
 
-    // Check for buffer overflow.
-    if (this->bytes_read_ >= this->max_telegram_len_) {
-      this->reset_telegram_();
-      ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-      return;
-    }
+        // Find a new telegram header, i.e. forward slash.
+        if (c == '/') {
+          ESP_LOGV(TAG, "Header of telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+        if (!this->header_found_)
+          continue;
 
-    // Some v2.2 or v3 meters will send a new value which starts with '('
-    // in a new line, while the value belongs to the previous ObisId. For
-    // proper parsing, remove these new line characters.
-    if (c == '(') {
-      while (true) {
-        auto previous_char = this->telegram_[this->bytes_read_ - 1];
-        if (previous_char == '\n' || previous_char == '\r') {
-          this->bytes_read_--;
-        } else {
-          break;
+        // Check for buffer overflow.
+        if (this->bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Some v2.2 or v3 meters will send a new value which starts with '('
+        // in a new line, while the value belongs to the previous ObisId. For
+        // proper parsing, remove these new line characters.
+        if (c == '(') {
+          while (true) {
+            auto previous_char = this->telegram_[this->bytes_read_ - 1];
+            if (previous_char == '\n' || previous_char == '\r') {
+              this->bytes_read_--;
+            } else {
+              break;
+            }
+          }
+        }
+
+        // Store the byte in the buffer.
+        this->telegram_[this->bytes_read_] = c;
+        this->bytes_read_++;
+
+        // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
+        if (c == '!') {
+          ESP_LOGV(TAG, "Footer of telegram found");
+          this->footer_found_ = true;
+          continue;
+        }
+        // Check for the end of the hex checksum, i.e. a newline.
+        if (this->footer_found_ && c == '\n') {
+          // Parse the telegram and publish sensor values.
+          this->parse_telegram();
+          this->reset_telegram_();
+          return;
         }
       }
     }
-
-    // Store the byte in the buffer.
-    this->telegram_[this->bytes_read_] = c;
-    this->bytes_read_++;
-
-    // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
-    if (c == '!') {
-      ESP_LOGV(TAG, "Footer of telegram found");
-      this->footer_found_ = true;
-      continue;
-    }
-    // Check for the end of the hex checksum, i.e. a newline.
-    if (this->footer_found_ && c == '\n') {
-      // Parse the telegram and publish sensor values.
-      this->parse_telegram();
-      this->reset_telegram_();
-      return;
-    }
   }
 }
 
 void Dsmr::receive_encrypted_telegram_() {
   while (this->available_within_timeout_()) {
-    const char c = this->read();
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    int avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
+      if (!this->read_array(buf, to_read))
+        return;
+      avail -= to_read;
 
-    // Find a new telegram start byte.
-    if (!this->header_found_) {
-      if ((uint8_t) c != 0xDB) {
-        continue;
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
+
+        // Find a new telegram start byte.
+        if (!this->header_found_) {
+          if ((uint8_t) c != 0xDB) {
+            continue;
+          }
+          ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+
+        // Check for buffer overflow.
+        if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Store the byte in the buffer.
+        this->crypt_telegram_[this->crypt_bytes_read_] = c;
+        this->crypt_bytes_read_++;
+
+        // Read the length of the incoming encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
+          // Complete header + data bytes
+          this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
+          ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
+        }
+
+        // Check for the end of the encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
+          continue;
+        }
+        ESP_LOGV(TAG, "End of encrypted telegram found");
+
+        // Decrypt the encrypted telegram.
+        GCM<AES128> *gcmaes128{new GCM<AES128>()};
+        gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
+        // the iv is 8 bytes of the system title + 4 bytes frame counter
+        // system title is at byte 2 and frame counter at byte 15
+        for (int i = 10; i < 14; i++)
+          this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
+        constexpr uint16_t iv_size{12};
+        gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
+        gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
+                           // the ciphertext start at byte 18
+                           &this->crypt_telegram_[18],
+                           // cipher size
+                           this->crypt_bytes_read_ - 17);
+        delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
+
+        this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
+        ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
+        ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
+
+        // Parse the decrypted telegram and publish sensor values.
+        this->parse_telegram();
+        this->reset_telegram_();
+        return;
       }
-      ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
-      this->reset_telegram_();
-      this->header_found_ = true;
     }
-
-    // Check for buffer overflow.
-    if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
-      this->reset_telegram_();
-      ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-      return;
-    }
-
-    // Store the byte in the buffer.
-    this->crypt_telegram_[this->crypt_bytes_read_] = c;
-    this->crypt_bytes_read_++;
-
-    // Read the length of the incoming encrypted telegram.
-    if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
-      // Complete header + data bytes
-      this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
-      ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
-    }
-
-    // Check for the end of the encrypted telegram.
-    if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
-      continue;
-    }
-    ESP_LOGV(TAG, "End of encrypted telegram found");
-
-    // Decrypt the encrypted telegram.
-    GCM<AES128> *gcmaes128{new GCM<AES128>()};
-    gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
-    // the iv is 8 bytes of the system title + 4 bytes frame counter
-    // system title is at byte 2 and frame counter at byte 15
-    for (int i = 10; i < 14; i++)
-      this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
-    constexpr uint16_t iv_size{12};
-    gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
-    gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
-                       // the ciphertext start at byte 18
-                       &this->crypt_telegram_[18],
-                       // cipher size
-                       this->crypt_bytes_read_ - 17);
-    delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
-
-    this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
-    ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
-    ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
-
-    // Parse the decrypted telegram and publish sensor values.
-    this->parse_telegram();
-    this->reset_telegram_();
-    return;
   }
 }
 

esphome/components/dsmr/dsmr.h

@@ -85,6 +85,7 @@ class Dsmr : public Component, public uart::UARTDevice {
   void receive_telegram_();
   void receive_encrypted_telegram_();
   void reset_telegram_();
+  void drain_rx_buffer_();
 
   /// Wait for UART data to become available within the read timeout.
   ///