Test the WHO_AM_I table against the datasheet values

esphome/components/display/display.cpp

@@ -5,6 +5,7 @@
 #include "display_color_utils.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::display {
@@ -52,40 +53,65 @@ void Display::line_at_angle(int x, int y, int angle, int start_radius, int stop_
   this->line(x1, y1, x2, y2, color);
 }
 
-void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
-  uint32_t color_value;
+// flatten keeps to_color() inlined in the pixel loop; in PSRAM builds GCC at
+// -Os stops inlining it once there are two call sites, which costs a call and
+// spills per pixel. Without PSRAM there is one call site and it changes
+// nothing, and draw_pixel_at() stays a virtual call either way.
+template<ColorBitness BITNESS>
+static void __attribute__((flatten))
+draw_packed_pixels(Display *display, int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                   bool big_endian, int x_offset, int y_offset, int x_pad) {
+  const size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
+  // BITNESS is a constant here, so to_color()'s three per pixel divisions
+  // become a multiply and shift and its bitness switch folds.
+  const auto draw_source_pixel = [&](int x, int y, size_t source_idx) ESPHOME_ALWAYS_INLINE {
+    display->draw_pixel_at(
+        x + x_start, y + y_start,
+        ColorUtil::to_color(ColorUtil::read_packed<BITNESS>(ptr, source_idx, big_endian), order, BITNESS));
+  };
+  // The source and frame buffers are row-major, so walking rows keeps the read
+  // and the write sequential. When the display swaps the axes before writing,
+  // walking columns keeps the write sequential instead; with the frame buffer
+  // in PSRAM a strided write costs more than a strided read.
+#ifdef USE_PSRAM
+  if (display->pixel_axes_swapped()) {
+    size_t column_idx = y_offset * line_stride + x_offset;
+    for (int x = 0; x != w; x++, column_idx++) {
+      size_t source_idx = column_idx;
+      for (int y = 0; y != h; y++, source_idx += line_stride) {
+        draw_source_pixel(x, y, source_idx);
+      }
+    }
+    return;
+  }
+#endif
+  // Row walk: builds without PSRAM, and PSRAM builds whose axes are not swapped.
   for (int y = 0; y != h; y++) {
     size_t source_idx = (y_offset + y) * line_stride + x_offset;
-    size_t source_idx_mod;
     for (int x = 0; x != w; x++, source_idx++) {
-      switch (bitness) {
-        default:
-          color_value = ptr[source_idx];
-          break;
-        case COLOR_BITNESS_565:
-          source_idx_mod = source_idx * 2;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod] << 8) + ptr[source_idx_mod + 1];
-          } else {
-            color_value = ptr[source_idx_mod] + (ptr[source_idx_mod + 1] << 8);
-          }
-          break;
-        case COLOR_BITNESS_888:
-          source_idx_mod = source_idx * 3;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod + 0] << 16) + (ptr[source_idx_mod + 1] << 8) + ptr[source_idx_mod + 2];
-          } else {
-            color_value = ptr[source_idx_mod + 0] + (ptr[source_idx_mod + 1] << 8) + (ptr[source_idx_mod + 2] << 16);
-          }
-          break;
-      }
-      this->draw_pixel_at(x + x_start, y + y_start, ColorUtil::to_color(color_value, order, bitness));
+      draw_source_pixel(x, y, source_idx);
     }
   }
 }
 
+void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+  switch (bitness) {
+    case COLOR_BITNESS_565:
+      draw_packed_pixels<COLOR_BITNESS_565>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    case COLOR_BITNESS_888:
+      draw_packed_pixels<COLOR_BITNESS_888>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    default:
+      draw_packed_pixels<COLOR_BITNESS_332>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+  }
+}
+
 void HOT Display::horizontal_line(int x, int y, int width, Color color) {
   // Future: Could be made more efficient by manipulating buffer directly in certain rotations.
   for (int i = x; i < x + width; i++)

esphome/components/display/display.h

@@ -139,6 +139,11 @@ enum DisplayRotation {
   DISPLAY_ROTATION_270_DEGREES = 270,
 };
 
+/// Whether a rotation swaps the x and y axes.
+constexpr bool rotation_swaps_axes(DisplayRotation rotation) {
+  return rotation == DISPLAY_ROTATION_90_DEGREES || rotation == DISPLAY_ROTATION_270_DEGREES;
+}
+
 const int EDGES_TRIGON = 3;
 const int EDGES_TRIANGLE = 3;
 const int EDGES_TETRAGON = 4;
@@ -717,6 +722,12 @@ class Display : public PollingComponent {
 
   virtual DisplayRotation get_rotation() const { return this->rotation_; }
 
+  /// True when draw_pixel_at() swaps x and y before writing, so pixels that are
+  /// neighbours along x land a row apart in the frame buffer. Not the same as
+  /// get_width()/get_height() swapping: a display that rotates in hardware
+  /// reports swapped dimensions but writes unswapped pixels.
+  virtual bool pixel_axes_swapped() const { return rotation_swaps_axes(this->rotation_); }
+
   /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
    * returns the type the display is currently configured to.
    */

esphome/components/display/display_color_utils.h

@@ -2,6 +2,7 @@
 #include <array>
 #include <cstdint>
 #include "esphome/core/color.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome::display {
 enum ColorOrder : uint8_t { COLOR_ORDER_RGB = 0, COLOR_ORDER_BGR = 1, COLOR_ORDER_GRB = 2 };
@@ -10,6 +11,27 @@ inline static uint8_t esp_scale(uint8_t i, uint8_t scale, uint8_t max_value = 25
 
 class ColorUtil {
  public:
+  /// Reads one packed pixel of the given bitness from a source buffer into the
+  /// value to_color() takes. BITNESS is a template argument so the byte layout
+  /// folds; pass it on to to_color() as a constant too, and its channel scaling
+  /// divides by a constant, which the compiler turns into a multiply and shift.
+  template<ColorBitness BITNESS>
+  static ESPHOME_ALWAYS_INLINE uint32_t read_packed(const uint8_t *ptr, size_t index, bool big_endian) {
+    if constexpr (BITNESS == COLOR_BITNESS_565) {
+      const size_t idx = index * 2;
+      if (big_endian)
+        return (ptr[idx] << 8) + ptr[idx + 1];
+      return ptr[idx] + (ptr[idx + 1] << 8);
+    } else if constexpr (BITNESS == COLOR_BITNESS_888) {
+      const size_t idx = index * 3;
+      if (big_endian)
+        return (ptr[idx + 0] << 16) + (ptr[idx + 1] << 8) + ptr[idx + 2];
+      return ptr[idx + 0] + (ptr[idx + 1] << 8) + (ptr[idx + 2] << 16);
+    } else {
+      return ptr[index];
+    }
+  }
+
   static Color to_color(uint32_t colorcode, ColorOrder color_order,
                         ColorBitness color_bitness = ColorBitness::COLOR_BITNESS_888, bool right_bit_aligned = true) {
     uint8_t first_color, second_color, third_color;

esphome/components/epaper_spi/epaper_spi.h

@@ -106,6 +106,7 @@ class EPaperBase : public Display,
 
   int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
   int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & SWAP_XY; }
   void draw_pixel_at(int x, int y, Color color) override;
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
                       ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;

esphome/components/it8951/it8951.h

@@ -204,6 +204,7 @@ class IT8951Display : public Display,
                       ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   int get_width() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->height_ : this->width_; }
   int get_height() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & TRANSFORM_SWAP_XY; }
 
  protected:
   int get_height_internal() override { return this->height_; }

esphome/components/lsm6ds/lsm6ds.cpp

@@ -1,15 +1,48 @@
 #include "lsm6ds.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/progmem.h"
 
 namespace esphome::lsm6ds {
 
 ESPHOME_LOG_TAG(TAG, "lsm6ds");
 
-static const struct {
-  uint8_t who_am_i;
-  const char *const name;
-} CHIP_IDS[] = {{0x69, "LSMDSO"}, {0x6A, "LSM6DS3"}};
+// Indexed by the accel range field, which is not in ascending order (datasheet Table 3)
+PROGMEM_STRING_TABLE(AccelRangeStrings, "±2g", "±16g", "±4g", "±8g");
+
+static const LogString *gyro_range_to_str(LSM6DSGyroRange range) {
+  switch (range) {
+    case LSM6DS_GYRO_RANGE_125:
+      return LOG_STR("±125dps");
+    case LSM6DS_GYRO_RANGE_250:
+      return LOG_STR("±250dps");
+    case LSM6DS_GYRO_RANGE_500:
+      return LOG_STR("±500dps");
+    case LSM6DS_GYRO_RANGE_1000:
+      return LOG_STR("±1000dps");
+    case LSM6DS_GYRO_RANGE_2000:
+      return LOG_STR("±2000dps");
+    default:
+      return LOG_STR("unknown");
+  }
+}
+
+const LogString *chip_name_from_who_am_i(uint8_t who_am_i) {
+  switch (who_am_i) {
+    case LSM6DS_WHO_AM_I_LSM6DS3:
+      return LOG_STR("LSM6DS3");
+    case LSM6DS_WHO_AM_I_LSM6DS3TR_C:
+      return LOG_STR("LSM6DS3TR-C");
+    case LSM6DS_WHO_AM_I_LSM6DSO:
+      return LOG_STR("LSM6DSO");
+    default:
+      return nullptr;
+  }
+}
+
+uint16_t temperature_sensitivity_from_who_am_i(uint8_t who_am_i) {
+  return who_am_i == LSM6DS_WHO_AM_I_LSM6DS3 ? 16 : 256;
+}
 
 void LSM6DSComponent::setup() {
   MotionComponent::setup();
@@ -19,20 +52,15 @@ void LSM6DSComponent::setup() {
     this->mark_failed();
     return;
   }
-  const char *chip_name = nullptr;
-  for (const auto &chip : CHIP_IDS) {
-    if (chip.who_am_i == who_am_i) {
-      chip_name = chip.name;
-      break;
-    }
-  }
+  const LogString *chip_name = chip_name_from_who_am_i(who_am_i);
   if (chip_name == nullptr) {
     ESP_LOGE(TAG, "Unknown WHO_AM_I: 0x%02X", who_am_i);
     this->mark_failed(LOG_STR("Unknown WHO_AM_I value"));
     return;
   }
-  ESP_LOGD(TAG, "Found %s (WHO_AM_I = 0x%02X)", chip_name, who_am_i);
+  ESP_LOGD(TAG, "Found %s (WHO_AM_I = 0x%02X)", LOG_STR_ARG(chip_name), who_am_i);
   this->chip_name_ = chip_name;
+  this->temperature_sensitivity_ = temperature_sensitivity_from_who_am_i(who_am_i);
 
   // 2. Software reset — clears all registers to defaults
   if (this->write_register(LSM6DS_REG_CTRL3_C, &CTRL3_C_SW_RESET, 1) != i2c::ERROR_OK) {
@@ -85,34 +113,10 @@ void LSM6DSComponent::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "LSM6DS IMU:\n"
                 "  Chip type: %s\n",
-                this->chip_name_);
+                LOG_STR_ARG(this->chip_name_ != nullptr ? this->chip_name_ : LOG_STR("Unknown")));
   LOG_I2C_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
 
-  // Accel range — index into the sensitivity table (datasheet Table 3)
-  static const char *const ACCEL_RANGE_STR[] = {"±2g", "±16g", "±4g", "±8g"};
-
-  const char *gyro_str;
-  switch (this->gyro_range_) {
-    case LSM6DS_GYRO_RANGE_125:
-      gyro_str = "±125dps";
-      break;
-    case LSM6DS_GYRO_RANGE_250:
-      gyro_str = "±250dps";
-      break;
-    case LSM6DS_GYRO_RANGE_500:
-      gyro_str = "±500dps";
-      break;
-    case LSM6DS_GYRO_RANGE_1000:
-      gyro_str = "±1000dps";
-      break;
-    case LSM6DS_GYRO_RANGE_2000:
-      gyro_str = "±2000dps";
-      break;
-    default:
-      gyro_str = "unknown";
-      break;
-  }
   auto accel_odr = this->accel_odr_ == 0 ? 0 : 13 * (1 << (this->accel_odr_ - 1));
   auto gyro_odr = this->gyro_odr_ == 0 ? 0 : 13 * (1 << (this->gyro_odr_ - 1));
   ESP_LOGCONFIG(TAG,
@@ -120,7 +124,8 @@ void LSM6DSComponent::dump_config() {
                 "  Accel data rate : %dHz\n"
                 "  Gyro  range : %s\n"
                 "  Gyro  data rate : %dHz",
-                ACCEL_RANGE_STR[this->accel_range_], accel_odr, gyro_str, gyro_odr);
+                LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)),
+                accel_odr, LOG_STR_ARG(gyro_range_to_str(this->gyro_range_)), gyro_odr);
 }
 
 //  update_data()
@@ -187,12 +192,12 @@ bool LSM6DSComponent::update_data(motion::MotionData &data) {
   //  Temperature (lazy — only read if a listener is registered)
   // Kept as a separate 2-byte read to avoid extending the burst to 14 bytes when
   // temperature is not needed.
-  // Formula: T(°C) = (raw / 256.0) + 25.0  (datasheet Table 90, OUT_TEMP register)
+  // Formula: T(°C) = raw / sensitivity + 25.0, sensitivity in LSB/°C per chip (0 LSB at 25 °C)
   if (!this->temperature_callback_.empty()) {
     uint8_t raw_t[2];
     if (this->read_bytes(LSM6DS_REG_OUT_TEMP_L, raw_t, 2)) {
       int16_t temp_raw = (int16_t) ((raw_t[1] << 8) | raw_t[0]);
-      float temperature = (temp_raw / 256.0f) + 25.0f;
+      float temperature = temp_raw / static_cast<float>(this->temperature_sensitivity_) + 25.0f;
       this->temperature_callback_.call(temperature);
     }
   }

esphome/components/lsm6ds/lsm6ds.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/log.h"
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/components/motion/motion_component.h"
 
@@ -8,15 +9,19 @@ namespace esphome::lsm6ds {
 
 // ── Register map (datasheet DocID030071 Rev 3, Table 19) ────────────────────
 static const uint8_t LSM6DS_REG_WHO_AM_I = 0x0F;
-static const uint8_t LSM6DS_REG_CTRL1_XL = 0x10;    // Accel ODR + FS
-static const uint8_t LSM6DS_REG_CTRL2_G = 0x11;     // Gyro ODR + FS
-static const uint8_t LSM6DS_REG_CTRL3_C = 0x12;     // SW_RESET, BDU, IF_INC
-static const uint8_t LSM6DS_REG_CTRL6_C = 0x15;     // Accel HP disable, Gyro LPF1
-static const uint8_t LSM6DS_REG_CTRL7_G = 0x16;     // Gyro HP disable
-static const uint8_t LSM6DS_REG_STATUS = 0x1E;      // XLDA, GDA, TDA
-static const uint8_t LSM6DS_REG_OUT_TEMP_L = 0x20;  // Temperature LSB
-static const uint8_t LSM6DS_REG_OUTX_L_G = 0x22;    // Gyro X LSB  (burst start)
-static const uint8_t LSM6DS_REG_OUTX_L_XL = 0x28;   // Accel X LSB
+// WHO_AM_I values; the LSM6DS3 (DocID026899) and LSM6DSO (DS12140) use the same registers as the TR-C here
+static const uint8_t LSM6DS_WHO_AM_I_LSM6DS3 = 0x69;
+static const uint8_t LSM6DS_WHO_AM_I_LSM6DS3TR_C = 0x6A;
+static const uint8_t LSM6DS_WHO_AM_I_LSM6DSO = 0x6C;  // also the LSM6DSO32, whose accel ranges differ (unsupported)
+static const uint8_t LSM6DS_REG_CTRL1_XL = 0x10;      // Accel ODR + FS
+static const uint8_t LSM6DS_REG_CTRL2_G = 0x11;       // Gyro ODR + FS
+static const uint8_t LSM6DS_REG_CTRL3_C = 0x12;       // SW_RESET, BDU, IF_INC
+static const uint8_t LSM6DS_REG_CTRL6_C = 0x15;       // Accel HP disable, Gyro LPF1
+static const uint8_t LSM6DS_REG_CTRL7_G = 0x16;       // Gyro HP disable
+static const uint8_t LSM6DS_REG_STATUS = 0x1E;        // XLDA, GDA, TDA
+static const uint8_t LSM6DS_REG_OUT_TEMP_L = 0x20;    // Temperature LSB
+static const uint8_t LSM6DS_REG_OUTX_L_G = 0x22;      // Gyro X LSB  (burst start)
+static const uint8_t LSM6DS_REG_OUTX_L_XL = 0x28;     // Accel X LSB
 
 // Burst read from 0x22 to 0x2D inclusive: gyro XYZ (6 bytes) + accel XYZ (6 bytes)
 static const uint8_t LSM6DS_BURST_LEN = 12;
@@ -82,6 +87,11 @@ enum LSM6DSGyroODR : uint8_t {
 };
 
 // ── Main component class ─────────────────────────────────────────────────────
+/// Chip name for a WHO_AM_I value, or nullptr when the chip is not supported.
+const LogString *chip_name_from_who_am_i(uint8_t who_am_i);
+/// Temperature sensitivity in LSB/°C for a supported WHO_AM_I value, from the chip's datasheet.
+uint16_t temperature_sensitivity_from_who_am_i(uint8_t who_am_i);
+
 class LSM6DSComponent final : public motion::MotionComponent, public i2c::I2CDevice {
  public:
   void setup() override;
@@ -97,13 +107,14 @@ class LSM6DSComponent final : public motion::MotionComponent, public i2c::I2CDev
   template<typename F> void add_temperature_listener(F &&cb) { this->temperature_callback_.add(std::forward<F>(cb)); }
 
  protected:
-  const char *chip_name_{"Unknown"};
+  const LogString *chip_name_{nullptr};
   bool update_data(motion::MotionData &data) override;
 
   LSM6DSAccelRange accel_range_{LSM6DS_ACCEL_RANGE_4G};
   LSM6DSAccelODR accel_odr_{LSM6DS_ACCEL_ODR_104};
   LSM6DSGyroRange gyro_range_{LSM6DS_GYRO_RANGE_2000};
   LSM6DSGyroODR gyro_odr_{LSM6DS_GYRO_ODR_208};
+  uint16_t temperature_sensitivity_{256};  // LSB/°C: 16 on the LSM6DS3, 256 on the others
 
   LazyCallbackManager<void(float)> temperature_callback_{};
 };

esphome/components/mipi_spi/mipi_spi.h

@@ -130,19 +130,8 @@ class MipiSpi : public display::Display,
   }
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
 
-  int get_width() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return HEIGHT;
-    return WIDTH;
-  }
-
-  int get_height() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return WIDTH;
-    return HEIGHT;
-  }
+  int get_width() override { return display::rotation_swaps_axes(this->rotation_) ? HEIGHT : WIDTH; }
+  int get_height() override { return display::rotation_swaps_axes(this->rotation_) ? WIDTH : HEIGHT; }
 
   void set_init_sequence(const uint8_t *sequence, size_t len) {
     this->init_sequence_ = sequence;
@@ -621,6 +610,9 @@ class MipiSpiBuffer
 #endif
   }
 
+  // With hardware rotation the buffer is written in drawn coordinates.
+  bool pixel_axes_swapped() const override { return !HAS_HARDWARE_ROTATION && display::Display::pixel_axes_swapped(); }
+
   // Draw a pixel at the given coordinates.
   void draw_pixel_at(int x, int y, Color color) override {
     if (this->is_point_clipped(x, y))

tests/components/display/__init__.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+import esphome.codegen as cg
+from esphome.const import CONF_ESPHOME, CONF_INCLUDES
+from esphome.core import CORE
+from esphome.types import ConfigType
+from tests.testing_helpers import ComponentManifestOverride
+
+TESTS_DIR = Path(__file__).parent
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # The column walk in Display::draw_pixels_at() is only built with PSRAM; define it
+    # when display's own tests are built so both walk orders run, and leave other
+    # components' test binaries on the plain build.
+    async def to_code_testing(config: ConfigType) -> None:
+        if any(Path(p) == TESTS_DIR for p in CORE.config[CONF_ESPHOME][CONF_INCLUDES]):
+            cg.add_define("USE_PSRAM")
+
+    manifest.to_code = to_code_testing

tests/components/display/test_draw_pixels_at.cpp

@@ -0,0 +1,109 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <initializer_list>
+#include <tuple>
+#include <vector>
+
+#include "esphome/components/display/display.h"
+
+namespace esphome::display::testing {
+
+// Records every pixel write; pixel_axes_swapped() picks the walk order.
+class RecordingDisplay : public Display {
+ public:
+  void set_axes_swapped(bool swapped) { this->axes_swapped_ = swapped; }
+  bool pixel_axes_swapped() const override { return this->axes_swapped_; }
+  void draw_pixel_at(int x, int y, Color color) override { this->pixels_.emplace_back(x, y, color.raw_32); }
+  void update() override {}
+  DisplayType get_display_type() override { return DisplayType::DISPLAY_TYPE_COLOR; }
+  int get_width_internal() override { return 64; }
+  int get_height_internal() override { return 64; }
+
+  std::vector<std::tuple<int, int, uint32_t>> sorted_pixels() const {
+    auto sorted = this->pixels_;
+    std::sort(sorted.begin(), sorted.end());
+    return sorted;
+  }
+  size_t count() const { return this->pixels_.size(); }
+  const std::vector<std::tuple<int, int, uint32_t>> &pixels() const { return this->pixels_; }
+
+ protected:
+  bool axes_swapped_{false};
+  std::vector<std::tuple<int, int, uint32_t>> pixels_;
+};
+
+// A 7x5 region with a 2 pixel left offset, a 3 line top offset and 4 pixels of
+// right padding, so the source index arithmetic of both walks is exercised.
+static constexpr int W = 7, H = 5, X_OFFSET = 2, Y_OFFSET = 3, X_PAD = 4;
+static constexpr int LINE_STRIDE = X_OFFSET + W + X_PAD;
+static constexpr int LINES = Y_OFFSET + H;
+
+static std::vector<uint8_t> make_source(int bytes_per_pixel) {
+  std::vector<uint8_t> source(LINE_STRIDE * LINES * bytes_per_pixel);
+  uint8_t value = 1;
+  for (auto &byte : source)
+    byte = value++;
+  return source;
+}
+
+static void expect_walks_match(ColorBitness bitness, int bytes_per_pixel, bool big_endian) {
+  const auto source = make_source(bytes_per_pixel);
+  RecordingDisplay rows;
+  RecordingDisplay columns;
+  columns.set_axes_swapped(true);
+  rows.draw_pixels_at(10, 20, W, H, source.data(), COLOR_ORDER_RGB, bitness, big_endian, X_OFFSET, Y_OFFSET, X_PAD);
+  columns.draw_pixels_at(10, 20, W, H, source.data(), COLOR_ORDER_RGB, bitness, big_endian, X_OFFSET, Y_OFFSET, X_PAD);
+  EXPECT_EQ(rows.count(), static_cast<size_t>(W * H));
+  EXPECT_EQ(columns.count(), static_cast<size_t>(W * H));
+  EXPECT_EQ(rows.sorted_pixels(), columns.sorted_pixels());
+}
+
+TEST(DrawPixelsAt, ColumnWalkMatchesRowWalk332) { expect_walks_match(COLOR_BITNESS_332, 1, true); }
+TEST(DrawPixelsAt, ColumnWalkMatchesRowWalk565BigEndian) { expect_walks_match(COLOR_BITNESS_565, 2, true); }
+TEST(DrawPixelsAt, ColumnWalkMatchesRowWalk565LittleEndian) { expect_walks_match(COLOR_BITNESS_565, 2, false); }
+TEST(DrawPixelsAt, ColumnWalkMatchesRowWalk888BigEndian) { expect_walks_match(COLOR_BITNESS_888, 3, true); }
+TEST(DrawPixelsAt, ColumnWalkMatchesRowWalk888LittleEndian) { expect_walks_match(COLOR_BITNESS_888, 3, false); }
+
+// One known pixel per bitness and byte order, so a decode that swapped bytes or channels
+// could not pass the walk comparison above by being wrong the same way twice.
+static void expect_golden(ColorBitness bitness, std::initializer_list<uint8_t> bytes, bool big_endian, Color expected) {
+  const std::vector<uint8_t> source(bytes);
+  RecordingDisplay display;
+  display.draw_pixels_at(3, 4, 1, 1, source.data(), COLOR_ORDER_RGB, bitness, big_endian, 0, 0, 0);
+  ASSERT_EQ(display.count(), 1u);
+  EXPECT_EQ(display.pixels()[0], std::make_tuple(3, 4, expected.raw_32));
+}
+
+TEST(DrawPixelsAt, Golden565BigEndian) {
+  expect_golden(COLOR_BITNESS_565, {0xE0, 0x07}, true, Color(230, 0, 57));  // 0xE007: r 28, g 0, b 7
+}
+TEST(DrawPixelsAt, Golden565LittleEndian) {
+  expect_golden(COLOR_BITNESS_565, {0xE0, 0x07}, false, Color(0, 255, 0));  // 0x07E0: pure green
+}
+TEST(DrawPixelsAt, Golden888BigEndian) {
+  expect_golden(COLOR_BITNESS_888, {0x10, 0x20, 0x30}, true, Color(0x10, 0x20, 0x30));
+}
+TEST(DrawPixelsAt, Golden888LittleEndian) {
+  expect_golden(COLOR_BITNESS_888, {0x10, 0x20, 0x30}, false, Color(0x30, 0x20, 0x10));
+}
+TEST(DrawPixelsAt, Golden332) {
+  expect_golden(COLOR_BITNESS_332, {0xE3}, true, Color(255, 0, 255));  // r 7 of 7, g 0, b 3 of 3
+}
+
+// The column walk really is a different order, otherwise the tests above prove nothing.
+TEST(DrawPixelsAt, ColumnWalkChangesOrder) {
+  const auto source = make_source(1);
+  RecordingDisplay rows;
+  RecordingDisplay columns;
+  columns.set_axes_swapped(true);
+  rows.draw_pixels_at(0, 0, W, H, source.data(), COLOR_ORDER_RGB, COLOR_BITNESS_332, true, X_OFFSET, Y_OFFSET, X_PAD);
+  columns.draw_pixels_at(0, 0, W, H, source.data(), COLOR_ORDER_RGB, COLOR_BITNESS_332, true, X_OFFSET, Y_OFFSET,
+                         X_PAD);
+  ASSERT_GT(rows.count(), 1u);
+  ASSERT_GT(columns.count(), 1u);
+  EXPECT_EQ(std::get<0>(rows.pixels()[1]), 1);     // the row walk steps x first
+  EXPECT_EQ(std::get<1>(columns.pixels()[1]), 1);  // the column walk steps y first
+}
+
+}  // namespace esphome::display::testing

tests/components/lsm6ds/__init__.py

@@ -0,0 +1,6 @@
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # lsm6ds declares i2c on its motion platform, which the harness does not walk
+    manifest.dependencies = manifest.dependencies + ["i2c", "motion"]

tests/components/lsm6ds/test_chip_ids.cpp

@@ -0,0 +1,38 @@
+#include <gtest/gtest.h>
+
+#include <cstring>
+
+#include "esphome/components/lsm6ds/lsm6ds.h"
+
+namespace esphome::lsm6ds::testing {
+
+// WHO_AM_I values and temperature sensitivities from ST's datasheets:
+// LSM6DS3 DocID026899, LSM6DS3TR-C DocID030071, LSM6DSO DS12140
+
+static const char *name_of(uint8_t who_am_i) {
+  const LogString *name = chip_name_from_who_am_i(who_am_i);
+  return name == nullptr ? nullptr : LOG_STR_ARG(name);
+}
+
+TEST(LSM6DSChipIds, Lsm6ds3) {
+  EXPECT_STREQ(name_of(0x69), "LSM6DS3");
+  EXPECT_EQ(temperature_sensitivity_from_who_am_i(0x69), 16);
+}
+
+TEST(LSM6DSChipIds, Lsm6ds3trC) {
+  EXPECT_STREQ(name_of(0x6A), "LSM6DS3TR-C");
+  EXPECT_EQ(temperature_sensitivity_from_who_am_i(0x6A), 256);
+}
+
+TEST(LSM6DSChipIds, Lsm6dso) {
+  EXPECT_STREQ(name_of(0x6C), "LSM6DSO");
+  EXPECT_EQ(temperature_sensitivity_from_who_am_i(0x6C), 256);
+}
+
+TEST(LSM6DSChipIds, UnknownIsRejected) {
+  EXPECT_EQ(name_of(0x00), nullptr);
+  EXPECT_EQ(name_of(0x6B), nullptr);
+  EXPECT_EQ(name_of(0xFF), nullptr);
+}
+
+}  // namespace esphome::lsm6ds::testing