tidy

esphome/components/cse7766/cse7766.cpp

@@ -2,6 +2,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include <cstdarg>
 
 namespace esphome {
 namespace cse7766 {
@@ -9,6 +10,32 @@ namespace cse7766 {
 static const char *const TAG = "cse7766";
 static constexpr size_t CSE7766_RAW_DATA_SIZE = 24;
 
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+/// @brief Safely append formatted string to buffer.
+/// @param buf Destination buffer (must be non-null)
+/// @param size Total buffer size in bytes
+/// @param pos Current write position (0 to size-1 for valid positions, size means full)
+/// @param fmt printf-style format string
+/// @return New write position: pos + chars_written, capped at size when buffer is full.
+///         Returns size (not size-1) when full because vsnprintf already wrote the null
+///         terminator at buf[size-1]. Returning size signals "no room for more content".
+///         On encoding error, returns pos unchanged (no write occurred).
+__attribute__((format(printf, 4, 5))) static size_t buf_append(char *buf, size_t size, size_t pos, const char *fmt,
+                                                               ...) {
+  if (pos >= size) {
+    return size;
+  }
+  va_list args;
+  va_start(args, fmt);
+  int written = vsnprintf(buf + pos, size - pos, fmt, args);
+  va_end(args);
+  if (written < 0) {
+    return pos;  // encoding error
+  }
+  return std::min(pos + static_cast<size_t>(written), size);
+}
+#endif
+
 void CSE7766Component::loop() {
   const uint32_t now = App.get_loop_component_start_time();
   if (now - this->last_transmission_ >= 500) {
@@ -207,20 +234,23 @@ void CSE7766Component::parse_data_() {
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   {
-    std::string buf = "Parsed:";
+    // Buffer: 7 + 15 + 33 + 15 + 25 = 95 chars max + null, rounded to 128 for safety margin.
+    // Float sizes with %.4f can be up to 11 chars for large values (e.g., 999999.9999).
+    char buf[128];
+    size_t pos = buf_append(buf, sizeof(buf), 0, "Parsed:");
     if (have_voltage) {
-      buf += str_sprintf(" V=%fV", voltage);
+      pos = buf_append(buf, sizeof(buf), pos, " V=%.4fV", voltage);
     }
     if (have_current) {
-      buf += str_sprintf(" I=%fmA (~%fmA)", current * 1000.0f, calculated_current * 1000.0f);
+      pos = buf_append(buf, sizeof(buf), pos, " I=%.4fmA (~%.4fmA)", current * 1000.0f, calculated_current * 1000.0f);
     }
     if (have_power) {
-      buf += str_sprintf(" P=%fW", power);
+      pos = buf_append(buf, sizeof(buf), pos, " P=%.4fW", power);
     }
     if (energy != 0.0f) {
-      buf += str_sprintf(" E=%fkWh (%u)", energy, cf_pulses);
+      buf_append(buf, sizeof(buf), pos, " E=%.4fkWh (%u)", energy, cf_pulses);
     }
-    ESP_LOGVV(TAG, "%s", buf.c_str());
+    ESP_LOGVV(TAG, "%s", buf);
   }
 #endif
 }

esphome/components/opentherm/opentherm.cpp

@@ -561,9 +561,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }
 
 void OpenTherm::debug_data(OpenthermData &data) {
-  char type_buf[9], id_buf[9], hb_buf[9], lb_buf[9];
-  ESP_LOGD(TAG, "%s %s %s %s", format_bin_to(type_buf, data.type), format_bin_to(id_buf, data.id),
-           format_bin_to(hb_buf, data.valueHB), format_bin_to(lb_buf, data.valueLB));
+  ESP_LOGD(TAG, "%s %s %s %s", format_bin(data.type).c_str(), format_bin(data.id).c_str(),
+           format_bin(data.valueHB).c_str(), format_bin(data.valueLB).c_str());
   ESP_LOGD(TAG, "type: %s; id: %u; HB: %u; LB: %u; uint_16: %u; float: %f",
            this->message_type_to_str((MessageType) data.type), data.id, data.valueHB, data.valueLB, data.u16(),
            data.f88());

esphome/core/helpers.cpp

@@ -404,31 +404,15 @@ std::string format_hex_pretty(const std::string &data, char separator, bool show
   return format_hex_pretty_uint8(reinterpret_cast<const uint8_t *>(data.data()), data.length(), separator, show_length);
 }
 
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
-  if (buffer_size == 0) {
-    return buffer;
-  }
-  // Calculate max bytes we can format: each byte needs 8 chars
-  size_t max_bytes = (buffer_size - 1) / 8;
-  if (max_bytes == 0 || length == 0) {
-    buffer[0] = '\0';
-    return buffer;
-  }
-  size_t bytes_to_format = std::min(length, max_bytes);
-
-  for (size_t byte_idx = 0; byte_idx < bytes_to_format; byte_idx++) {
-    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-      buffer[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
-    }
-  }
-  buffer[bytes_to_format * 8] = '\0';
-  return buffer;
-}
-
 std::string format_bin(const uint8_t *data, size_t length) {
   std::string result;
   result.resize(length * 8);
-  format_bin_to(&result[0], length * 8 + 1, data, length);
+  for (size_t byte_idx = 0; byte_idx < length; byte_idx++) {
+    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+      result[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
+    }
+  }
+
   return result;
 }
 

esphome/core/helpers.h

@@ -1045,66 +1045,9 @@ std::string format_hex_pretty(T val, char separator = '.', bool show_length = tr
   return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T), separator, show_length);
 }
 
-/// Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1
-constexpr size_t format_bin_size(size_t byte_count) { return byte_count * 8 + 1; }
-
-/** Format byte array as binary string to buffer.
- *
- * Each byte is formatted as 8 binary digits (MSB first).
- * Truncates output if data exceeds buffer capacity.
- *
- * @param buffer Output buffer to write to.
- * @param buffer_size Size of the output buffer.
- * @param data Pointer to the byte array to format.
- * @param length Number of bytes in the array.
- * @return Pointer to buffer.
- *
- * Buffer size needed: length * 8 + 1 (use format_bin_size()).
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(1)
- * format_bin_to(buf, sizeof(buf), data, 1);  // "10101011"
- * @endcode
- */
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
-
-/// Format byte array as binary to buffer. Automatically deduces buffer size.
-template<size_t N> inline char *format_bin_to(char (&buffer)[N], const uint8_t *data, size_t length) {
-  static_assert(N >= 9, "Buffer must hold at least one binary byte (9 chars)");
-  return format_bin_to(buffer, N, data, length);
-}
-
-/** Format an unsigned integer in binary to buffer, MSB first.
- *
- * @tparam N Buffer size (must be >= sizeof(T) * 8 + 1).
- * @tparam T Unsigned integer type.
- * @param buffer Output buffer to write to.
- * @param val The unsigned integer value to format.
- * @return Pointer to buffer.
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(sizeof(uint8_t))
- * format_bin_to(buf, uint8_t{0xAA});  // "10101010"
- * char buf16[17];  // format_bin_size(sizeof(uint16_t))
- * format_bin_to(buf16, uint16_t{0x1234});  // "0001001000110100"
- * @endcode
- */
-template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-inline char *format_bin_to(char (&buffer)[N], T val) {
-  static_assert(N >= sizeof(T) * 8 + 1, "Buffer too small for type");
-  val = convert_big_endian(val);
-  return format_bin_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
-}
-
 /// Format the byte array \p data of length \p len in binary.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 std::string format_bin(const uint8_t *data, size_t length);
 /// Format an unsigned integer in binary, starting with the most significant byte.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
   val = convert_big_endian(val);
   return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));

script/ci-custom.py

@@ -682,7 +682,6 @@ def lint_trailing_whitespace(fname, match):
 # Heap-allocating helpers that cause fragmentation on long-running embedded devices.
 # These return std::string and should be replaced with stack-based alternatives.
 HEAP_ALLOCATING_HELPERS = {
-    "format_bin": "format_bin_to() with a stack buffer",
     "format_hex": "format_hex_to() with a stack buffer",
     "format_hex_pretty": "format_hex_pretty_to() with a stack buffer",
     "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
@@ -700,7 +699,6 @@ HEAP_ALLOCATING_HELPERS = {
     # get_mac_address(?!_) ensures we don't match get_mac_address_into_buffer, etc.
     # CPP_RE_EOL captures rest of line so NOLINT comments are detected
     r"[^\w]("
-    r"format_bin(?!_)|"
     r"format_hex(?!_)|"
     r"format_hex_pretty(?!_)|"
     r"format_mac_address_pretty|"