Merge remote-tracking branch 'origin/dev' into udp

CODEOWNERS

@@ -237,6 +237,7 @@ esphome/components/ltr_als_ps/* @latonita
 esphome/components/lvgl/* @clydebarrow
 esphome/components/m5stack_8angle/* @rnauber
 esphome/components/matrix_keypad/* @ssieb
+esphome/components/max17043/* @blacknell
 esphome/components/max31865/* @DAVe3283
 esphome/components/max44009/* @berfenger
 esphome/components/max6956/* @looping40
@@ -324,7 +325,7 @@ esphome/components/pvvx_mithermometer/* @pasiz
 esphome/components/pylontech/* @functionpointer
 esphome/components/qmp6988/* @andrewpc
 esphome/components/qr_code/* @wjtje
-esphome/components/qspi_amoled/* @clydebarrow
+esphome/components/qspi_dbi/* @clydebarrow
 esphome/components/qwiic_pir/* @kahrendt
 esphome/components/radon_eye_ble/* @jeffeb3
 esphome/components/radon_eye_rd200/* @jeffeb3
@@ -403,6 +404,7 @@ esphome/components/sun/* @OttoWinter
 esphome/components/sun_gtil2/* @Mat931
 esphome/components/switch/* @esphome/core
 esphome/components/t6615/* @tylermenezes
+esphome/components/tc74/* @sethgirvan
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski
 esphome/components/tcl112/* @glmnet

docker/Dockerfile

@@ -86,7 +86,7 @@ RUN \
     pip3 install \
     --break-system-packages --no-cache-dir \
     # Keep platformio version in sync with requirements.txt
-    platformio==6.1.15 \
+    platformio==6.1.16 \
     # Change some platformio settings
     && platformio settings set enable_telemetry No \
     && platformio settings set check_platformio_interval 1000000 \

esphome/automation.py

@@ -1,6 +1,8 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALL,
+    CONF_ANY,
     CONF_AUTOMATION_ID,
     CONF_CONDITION,
     CONF_COUNT,
@@ -73,6 +75,13 @@ def validate_potentially_and_condition(value):
     return validate_condition(value)
 
 
+def validate_potentially_or_condition(value):
+    if isinstance(value, list):
+        with cv.remove_prepend_path(["or"]):
+            return validate_condition({"or": value})
+    return validate_condition(value)
+
+
 DelayAction = cg.esphome_ns.class_("DelayAction", Action, cg.Component)
 LambdaAction = cg.esphome_ns.class_("LambdaAction", Action)
 IfAction = cg.esphome_ns.class_("IfAction", Action)
@@ -166,6 +175,18 @@ async def or_condition_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg, conditions)
 
 
+@register_condition("all", AndCondition, validate_condition_list)
+async def all_condition_to_code(config, condition_id, template_arg, args):
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(condition_id, template_arg, conditions)
+
+
+@register_condition("any", OrCondition, validate_condition_list)
+async def any_condition_to_code(config, condition_id, template_arg, args):
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(condition_id, template_arg, conditions)
+
+
 @register_condition("not", NotCondition, validate_potentially_and_condition)
 async def not_condition_to_code(config, condition_id, template_arg, args):
     condition = await build_condition(config, template_arg, args)
@@ -223,15 +244,21 @@ async def delay_action_to_code(config, action_id, template_arg, args):
     IfAction,
     cv.All(
         {
-            cv.Required(CONF_CONDITION): validate_potentially_and_condition,
+            cv.Exclusive(
+                CONF_CONDITION, CONF_CONDITION
+            ): validate_potentially_and_condition,
+            cv.Exclusive(CONF_ANY, CONF_CONDITION): validate_potentially_or_condition,
+            cv.Exclusive(CONF_ALL, CONF_CONDITION): validate_potentially_and_condition,
             cv.Optional(CONF_THEN): validate_action_list,
             cv.Optional(CONF_ELSE): validate_action_list,
         },
         cv.has_at_least_one_key(CONF_THEN, CONF_ELSE),
+        cv.has_at_least_one_key(CONF_CONDITION, CONF_ANY, CONF_ALL),
     ),
 )
 async def if_action_to_code(config, action_id, template_arg, args):
-    conditions = await build_condition(config[CONF_CONDITION], template_arg, args)
+    cond_conf = next(el for el in config if el in (CONF_ANY, CONF_ALL, CONF_CONDITION))
+    conditions = await build_condition(config[cond_conf], template_arg, args)
     var = cg.new_Pvariable(action_id, template_arg, conditions)
     if CONF_THEN in config:
         actions = await build_action_list(config[CONF_THEN], template_arg, args)

esphome/components/display/display.cpp

@@ -156,6 +156,148 @@ void Display::filled_circle(int center_x, int center_y, int radius, Color color)
     }
   } while (dx <= 0);
 }
+void Display::filled_ring(int center_x, int center_y, int radius1, int radius2, Color color) {
+  int rmax = radius1 > radius2 ? radius1 : radius2;
+  int rmin = radius1 < radius2 ? radius1 : radius2;
+  int dxmax = -int32_t(rmax), dxmin = -int32_t(rmin);
+  int dymax = 0, dymin = 0;
+  int errmax = 2 - 2 * rmax, errmin = 2 - 2 * rmin;
+  int e2max, e2min;
+  do {
+    // 8 dots for borders
+    this->draw_pixel_at(center_x - dxmax, center_y + dymax, color);
+    this->draw_pixel_at(center_x + dxmax, center_y + dymax, color);
+    this->draw_pixel_at(center_x - dxmin, center_y + dymin, color);
+    this->draw_pixel_at(center_x + dxmin, center_y + dymin, color);
+    this->draw_pixel_at(center_x + dxmax, center_y - dymax, color);
+    this->draw_pixel_at(center_x - dxmax, center_y - dymax, color);
+    this->draw_pixel_at(center_x + dxmin, center_y - dymin, color);
+    this->draw_pixel_at(center_x - dxmin, center_y - dymin, color);
+    if (dymin < rmin) {
+      // two parts - four lines
+      int hline_width = -(dxmax - dxmin) + 1;
+      this->horizontal_line(center_x + dxmax, center_y + dymax, hline_width, color);
+      this->horizontal_line(center_x - dxmin, center_y + dymax, hline_width, color);
+      this->horizontal_line(center_x + dxmax, center_y - dymax, hline_width, color);
+      this->horizontal_line(center_x - dxmin, center_y - dymax, hline_width, color);
+    } else {
+      // one part - top and bottom
+      int hline_width = 2 * (-dxmax) + 1;
+      this->horizontal_line(center_x + dxmax, center_y + dymax, hline_width, color);
+      this->horizontal_line(center_x + dxmax, center_y - dymax, hline_width, color);
+    }
+    e2max = errmax;
+    // tune external
+    if (e2max < dymax) {
+      errmax += ++dymax * 2 + 1;
+      if (-dxmax == dymax && e2max <= dxmax) {
+        e2max = 0;
+      }
+    }
+    if (e2max > dxmax) {
+      errmax += ++dxmax * 2 + 1;
+    }
+    // tune internal
+    while (dymin < dymax && dymin < rmin) {
+      e2min = errmin;
+      if (e2min < dymin) {
+        errmin += ++dymin * 2 + 1;
+        if (-dxmin == dymin && e2min <= dxmin) {
+          e2min = 0;
+        }
+      }
+      if (e2min > dxmin) {
+        errmin += ++dxmin * 2 + 1;
+      }
+    }
+  } while (dxmax <= 0);
+}
+void Display::filled_gauge(int center_x, int center_y, int radius1, int radius2, int progress, Color color) {
+  int rmax = radius1 > radius2 ? radius1 : radius2;
+  int rmin = radius1 < radius2 ? radius1 : radius2;
+  int dxmax = -int32_t(rmax), dxmin = -int32_t(rmin), upd_dxmax, upd_dxmin;
+  int dymax = 0, dymin = 0;
+  int errmax = 2 - 2 * rmax, errmin = 2 - 2 * rmin;
+  int e2max, e2min;
+  progress = std::max(0, std::min(progress, 100));  // 0..100
+  int draw_progress = progress > 50 ? (100 - progress) : progress;
+  float tan_a = (progress == 50) ? 65535 : tan(float(draw_progress) * M_PI / 100);  // slope
+
+  do {
+    // outer dots
+    this->draw_pixel_at(center_x + dxmax, center_y - dymax, color);
+    this->draw_pixel_at(center_x - dxmax, center_y - dymax, color);
+    if (dymin < rmin) {  // side parts
+      int lhline_width = -(dxmax - dxmin) + 1;
+      if (progress >= 50) {
+        if (float(dymax) < float(-dxmax) * tan_a) {
+          upd_dxmax = ceil(float(dymax) / tan_a);
+        } else {
+          upd_dxmax = -dxmax;
+        }
+        this->horizontal_line(center_x + dxmax, center_y - dymax, lhline_width, color);  // left
+        if (!dymax)
+          this->horizontal_line(center_x - dxmin, center_y, lhline_width, color);  // right horizontal border
+        if (upd_dxmax > -dxmin) {                                                  // right
+          int rhline_width = (upd_dxmax + dxmin) + 1;
+          this->horizontal_line(center_x - dxmin, center_y - dymax,
+                                rhline_width > lhline_width ? lhline_width : rhline_width, color);
+        }
+      } else {
+        if (float(dymin) > float(-dxmin) * tan_a) {
+          upd_dxmin = ceil(float(dymin) / tan_a);
+        } else {
+          upd_dxmin = -dxmin;
+        }
+        lhline_width = -(dxmax + upd_dxmin) + 1;
+        if (!dymax)
+          this->horizontal_line(center_x - dxmin, center_y, lhline_width, color);  // right horizontal border
+        if (lhline_width > 0)
+          this->horizontal_line(center_x + dxmax, center_y - dymax, lhline_width, color);
+      }
+    } else {  // top part
+      int hline_width = 2 * (-dxmax) + 1;
+      if (progress >= 50) {
+        if (dymax < float(-dxmax) * tan_a) {
+          upd_dxmax = ceil(float(dymax) / tan_a);
+          hline_width = -dxmax + upd_dxmax + 1;
+        }
+      } else {
+        if (dymax < float(-dxmax) * tan_a) {
+          upd_dxmax = ceil(float(dymax) / tan_a);
+          hline_width = -dxmax - upd_dxmax + 1;
+        } else
+          hline_width = 0;
+      }
+      if (hline_width > 0)
+        this->horizontal_line(center_x + dxmax, center_y - dymax, hline_width, color);
+    }
+    e2max = errmax;
+    if (e2max < dymax) {
+      errmax += ++dymax * 2 + 1;
+      if (-dxmax == dymax && e2max <= dxmax) {
+        e2max = 0;
+      }
+    }
+    if (e2max > dxmax) {
+      errmax += ++dxmax * 2 + 1;
+    }
+    while (dymin <= dymax && dymin <= rmin && dxmin <= 0) {
+      this->draw_pixel_at(center_x + dxmin, center_y - dymin, color);
+      this->draw_pixel_at(center_x - dxmin, center_y - dymin, color);
+      e2min = errmin;
+      if (e2min < dymin) {
+        errmin += ++dymin * 2 + 1;
+        if (-dxmin == dymin && e2min <= dxmin) {
+          e2min = 0;
+        }
+      }
+      if (e2min > dxmin) {
+        errmin += ++dxmin * 2 + 1;
+      }
+    }
+  } while (dxmax <= 0);
+}
 void HOT Display::triangle(int x1, int y1, int x2, int y2, int x3, int y3, Color color) {
   this->line(x1, y1, x2, y2, color);
   this->line(x1, y1, x3, y3, color);

esphome/components/display/display.h

@@ -285,6 +285,13 @@ class Display : public PollingComponent {
   /// Fill a circle centered around [center_x,center_y] with the radius radius with the given color.
   void filled_circle(int center_x, int center_y, int radius, Color color = COLOR_ON);
 
+  /// Fill a ring centered around [center_x,center_y] between two circles with the radius1 and radius2 with the given
+  /// color.
+  void filled_ring(int center_x, int center_y, int radius1, int radius2, Color color = COLOR_ON);
+  /// Fill a half-ring "gauge" centered around [center_x,center_y] between two circles with the radius1 and radius2
+  /// with he given color and filled up to 'progress' percent
+  void filled_gauge(int center_x, int center_y, int radius1, int radius2, int progress, Color color = COLOR_ON);
+
   /// Draw the outline of a triangle contained between the points [x1,y1], [x2,y2] and [x3,y3] with the given color.
   void triangle(int x1, int y1, int x2, int y2, int x3, int y3, Color color = COLOR_ON);
 

esphome/components/ili9xxx/display.py

@@ -10,6 +10,7 @@ from esphome.const import (
     CONF_DIMENSIONS,
     CONF_HEIGHT,
     CONF_ID,
+    CONF_INIT_SEQUENCE,
     CONF_INVERT_COLORS,
     CONF_LAMBDA,
     CONF_MIRROR_X,
@@ -89,7 +90,6 @@ CONF_LED_PIN = "led_pin"
 CONF_COLOR_PALETTE_IMAGES = "color_palette_images"
 CONF_INVERT_DISPLAY = "invert_display"
 CONF_PIXEL_MODE = "pixel_mode"
-CONF_INIT_SEQUENCE = "init_sequence"
 
 
 def cmd(c, *args):

esphome/components/logger/logger_esp32.cpp

@@ -10,8 +10,12 @@
 
 #ifdef USE_LOGGER_USB_SERIAL_JTAG
 #include <driver/usb_serial_jtag.h>
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 3, 0)
 #include <esp_vfs_dev.h>
 #include <esp_vfs_usb_serial_jtag.h>
+#else
+#include <driver/usb_serial_jtag_vfs.h>
+#endif
 #endif
 
 #include "freertos/FreeRTOS.h"
@@ -36,10 +40,17 @@ static const char *const TAG = "logger";
 static void init_usb_serial_jtag_() {
   setvbuf(stdin, NULL, _IONBF, 0);  // Disable buffering on stdin
 
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 3, 0)
   // Minicom, screen, idf_monitor send CR when ENTER key is pressed
   esp_vfs_dev_usb_serial_jtag_set_rx_line_endings(ESP_LINE_ENDINGS_CR);
   // Move the caret to the beginning of the next line on '\n'
   esp_vfs_dev_usb_serial_jtag_set_tx_line_endings(ESP_LINE_ENDINGS_CRLF);
+#else
+  // Minicom, screen, idf_monitor send CR when ENTER key is pressed
+  usb_serial_jtag_vfs_set_rx_line_endings(ESP_LINE_ENDINGS_CR);
+  // Move the caret to the beginning of the next line on '\n'
+  usb_serial_jtag_vfs_set_tx_line_endings(ESP_LINE_ENDINGS_CRLF);
+#endif
 
   // Enable non-blocking mode on stdin and stdout
   fcntl(fileno(stdout), F_SETFL, 0);
@@ -57,7 +68,11 @@ static void init_usb_serial_jtag_() {
   }
 
   // Tell vfs to use usb-serial-jtag driver
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 3, 0)
   esp_vfs_usb_serial_jtag_use_driver();
+#else
+  usb_serial_jtag_vfs_use_driver();
+#endif
 }
 #endif
 

esphome/components/lvgl/__init__.py

@@ -48,6 +48,7 @@ from .types import (
     FontEngine,
     IdleTrigger,
     ObjUpdateAction,
+    PauseTrigger,
     lv_font_t,
     lv_group_t,
     lv_style_t,
@@ -233,6 +234,8 @@ async def to_code(config):
         frac = 8
     cg.add(lv_component.set_buffer_frac(int(frac)))
     cg.add(lv_component.set_full_refresh(config[df.CONF_FULL_REFRESH]))
+    cg.add(lv_component.set_draw_rounding(config[df.CONF_DRAW_ROUNDING]))
+    cg.add(lv_component.set_resume_on_input(config[df.CONF_RESUME_ON_INPUT]))
 
     for font in helpers.esphome_fonts_used:
         await cg.get_variable(font)
@@ -272,11 +275,19 @@ async def to_code(config):
     async with LvContext(lv_component):
         await generate_triggers(lv_component)
         await generate_page_triggers(lv_component, config)
+        await initial_focus_to_code(config)
         for conf in config.get(CONF_ON_IDLE, ()):
             templ = await cg.templatable(conf[CONF_TIMEOUT], [], cg.uint32)
             idle_trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], lv_component, templ)
             await build_automation(idle_trigger, [], conf)
-        await initial_focus_to_code(config)
+        for conf in config.get(df.CONF_ON_PAUSE, ()):
+            pause_trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], lv_component, True)
+            await build_automation(pause_trigger, [], conf)
+        for conf in config.get(df.CONF_ON_RESUME, ()):
+            resume_trigger = cg.new_Pvariable(
+                conf[CONF_TRIGGER_ID], lv_component, False
+            )
+            await build_automation(resume_trigger, [], conf)
 
     for comp in helpers.lvgl_components_required:
         CORE.add_define(f"USE_LVGL_{comp.upper()}")
@@ -314,6 +325,7 @@ CONFIG_SCHEMA = (
             cv.Optional(df.CONF_COLOR_DEPTH, default=16): cv.one_of(16),
             cv.Optional(df.CONF_DEFAULT_FONT, default="montserrat_14"): lvalid.lv_font,
             cv.Optional(df.CONF_FULL_REFRESH, default=False): cv.boolean,
+            cv.Optional(df.CONF_DRAW_ROUNDING, default=2): cv.positive_int,
             cv.Optional(CONF_BUFFER_SIZE, default="100%"): cv.percentage,
             cv.Optional(df.CONF_LOG_LEVEL, default="WARN"): cv.one_of(
                 *df.LOG_LEVELS, upper=True
@@ -341,6 +353,16 @@ CONFIG_SCHEMA = (
                     ),
                 }
             ),
+            cv.Optional(df.CONF_ON_PAUSE): validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
+                }
+            ),
+            cv.Optional(df.CONF_ON_RESUME): validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(PauseTrigger),
+                }
+            ),
             cv.Exclusive(df.CONF_WIDGETS, CONF_PAGES): cv.ensure_list(WIDGET_SCHEMA),
             cv.Exclusive(CONF_PAGES, CONF_PAGES): cv.ensure_list(
                 container_schema(page_spec)
@@ -356,6 +378,7 @@ CONFIG_SCHEMA = (
             cv.Optional(df.CONF_TOUCHSCREENS, default=None): touchscreen_schema,
             cv.Optional(df.CONF_ENCODERS, default=None): ENCODERS_CONFIG,
             cv.GenerateID(df.CONF_DEFAULT_GROUP): cv.declare_id(lv_group_t),
+            cv.Optional(df.CONF_RESUME_ON_INPUT, default=True): cv.boolean,
         }
     )
     .extend(DISP_BG_SCHEMA)

esphome/components/lvgl/defines.py

@@ -408,6 +408,7 @@ CONF_DEFAULT_FONT = "default_font"
 CONF_DEFAULT_GROUP = "default_group"
 CONF_DIR = "dir"
 CONF_DISPLAYS = "displays"
+CONF_DRAW_ROUNDING = "draw_rounding"
 CONF_EDITING = "editing"
 CONF_ENCODERS = "encoders"
 CONF_END_ANGLE = "end_angle"
@@ -451,6 +452,8 @@ CONF_OFFSET_X = "offset_x"
 CONF_OFFSET_Y = "offset_y"
 CONF_ONE_CHECKED = "one_checked"
 CONF_ONE_LINE = "one_line"
+CONF_ON_PAUSE = "on_pause"
+CONF_ON_RESUME = "on_resume"
 CONF_ON_SELECT = "on_select"
 CONF_OPA = "opa"
 CONF_NEXT = "next"
@@ -466,6 +469,7 @@ CONF_POINTS = "points"
 CONF_PREVIOUS = "previous"
 CONF_REPEAT_COUNT = "repeat_count"
 CONF_RECOLOR = "recolor"
+CONF_RESUME_ON_INPUT = "resume_on_input"
 CONF_RIGHT_BUTTON = "right_button"
 CONF_ROLLOVER = "rollover"
 CONF_ROOT_BACK_BTN = "root_back_btn"

esphome/components/lvgl/lvgl_esphome.cpp

@@ -69,30 +69,38 @@ std::string lv_event_code_name_for(uint8_t event_code) {
   }
   return str_sprintf("%2d", event_code);
 }
+
 static void rounder_cb(lv_disp_drv_t *disp_drv, lv_area_t *area) {
-  // make sure all coordinates are even
+  // cater for display driver chips with special requirements for bounds of partial
-  if (area->x1 & 1)
+  // draw areas. Extend the draw area to satisfy:
-    area->x1--;
+  // * Coordinates must be a multiple of draw_rounding
-  if (!(area->x2 & 1))
+  auto *comp = static_cast<LvglComponent *>(disp_drv->user_data);
-    area->x2++;
+  auto draw_rounding = comp->draw_rounding;
-  if (area->y1 & 1)
+  // round down the start coordinates
-    area->y1--;
+  area->x1 = area->x1 / draw_rounding * draw_rounding;
-  if (!(area->y2 & 1))
+  area->y1 = area->y1 / draw_rounding * draw_rounding;
-    area->y2++;
+  // round up the end coordinates
+  area->x2 = (area->x2 + draw_rounding) / draw_rounding * draw_rounding - 1;
+  area->y2 = (area->y2 + draw_rounding) / draw_rounding * draw_rounding - 1;
 }
 
 lv_event_code_t lv_api_event;     // NOLINT
 lv_event_code_t lv_update_event;  // NOLINT
-void LvglComponent::dump_config() { ESP_LOGCONFIG(TAG, "LVGL:"); }
+void LvglComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "LVGL:");
+  ESP_LOGCONFIG(TAG, "  Rotation: %d", this->rotation);
+  ESP_LOGCONFIG(TAG, "  Draw rounding: %d", (int) this->draw_rounding);
+}
 void LvglComponent::set_paused(bool paused, bool show_snow) {
   this->paused_ = paused;
   this->show_snow_ = show_snow;
-  this->snow_line_ = 0;
   if (!paused && lv_scr_act() != nullptr) {
     lv_disp_trig_activity(this->disp_);  // resets the inactivity time
     lv_obj_invalidate(lv_scr_act());
   }
+  this->pause_callbacks_.call(paused);
 }
+
 void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event) {
   lv_obj_add_event_cb(obj, callback, event, this);
 }
@@ -133,19 +141,64 @@ void LvglComponent::show_prev_page(lv_scr_load_anim_t anim, uint32_t time) {
   } while (this->pages_[this->current_page_]->skip);  // skip empty pages()
   this->show_page(this->current_page_, anim, time);
 }
-void LvglComponent::draw_buffer_(const lv_area_t *area, const uint8_t *ptr) {
+void LvglComponent::draw_buffer_(const lv_area_t *area, lv_color_t *ptr) {
+  auto width = lv_area_get_width(area);
+  auto height = lv_area_get_height(area);
+  auto x1 = area->x1;
+  auto y1 = area->y1;
+  lv_color_t *dst = this->rotate_buf_;
+  switch (this->rotation) {
+    case display::DISPLAY_ROTATION_90_DEGREES:
+      for (lv_coord_t x = height - 1; x-- != 0;) {
+        for (lv_coord_t y = 0; y != width; y++) {
+          dst[y * height + x] = *ptr++;
+        }
+      }
+      y1 = x1;
+      x1 = this->disp_drv_.ver_res - area->y1 - height;
+      width = height;
+      height = lv_area_get_width(area);
+      break;
+
+    case display::DISPLAY_ROTATION_180_DEGREES:
+      for (lv_coord_t y = height; y-- != 0;) {
+        for (lv_coord_t x = width; x-- != 0;) {
+          dst[y * width + x] = *ptr++;
+        }
+      }
+      x1 = this->disp_drv_.hor_res - x1 - width;
+      y1 = this->disp_drv_.ver_res - y1 - height;
+      break;
+
+    case display::DISPLAY_ROTATION_270_DEGREES:
+      for (lv_coord_t x = 0; x != height; x++) {
+        for (lv_coord_t y = width; y-- != 0;) {
+          dst[y * height + x] = *ptr++;
+        }
+      }
+      x1 = y1;
+      y1 = this->disp_drv_.hor_res - area->x1 - width;
+      width = height;
+      height = lv_area_get_width(area);
+      break;
+
+    default:
+      dst = ptr;
+      break;
+  }
   for (auto *display : this->displays_) {
-    display->draw_pixels_at(area->x1, area->y1, lv_area_get_width(area), lv_area_get_height(area), ptr,
+    ESP_LOGV(TAG, "draw buffer x1=%d, y1=%d, width=%d, height=%d", x1, y1, width, height);
-                            display::COLOR_ORDER_RGB, LV_BITNESS, LV_COLOR_16_SWAP);
+    display->draw_pixels_at(x1, y1, width, height, (const uint8_t *) dst, display::COLOR_ORDER_RGB, LV_BITNESS,
+                            LV_COLOR_16_SWAP);
   }
 }
 
 void LvglComponent::flush_cb_(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p) {
   if (!this->paused_) {
     auto now = millis();
-    this->draw_buffer_(area, (const uint8_t *) color_p);
+    this->draw_buffer_(area, color_p);
-    ESP_LOGV(TAG, "flush_cb, area=%d/%d, %d/%d took %dms", area->x1, area->y1, lv_area_get_width(area),
+    ESP_LOGVV(TAG, "flush_cb, area=%d/%d, %d/%d took %dms", area->x1, area->y1, lv_area_get_width(area),
-             lv_area_get_height(area), (int) (millis() - now));
+              lv_area_get_height(area), (int) (millis() - now));
   }
   lv_disp_flush_ready(disp_drv);
 }
@@ -160,6 +213,13 @@ IdleTrigger::IdleTrigger(LvglComponent *parent, TemplatableValue<uint32_t> timeo
   });
 }
 
+PauseTrigger::PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused) : paused_(std::move(paused)) {
+  parent->add_on_pause_callback([this](bool pausing) {
+    if (this->paused_.value() == pausing)
+      this->trigger();
+  });
+}
+
 #ifdef USE_LVGL_TOUCHSCREEN
 LVTouchListener::LVTouchListener(uint16_t long_press_time, uint16_t long_press_repeat_time) {
   lv_indev_drv_init(&this->drv_);
@@ -261,23 +321,31 @@ void LvKeyboardType::set_obj(lv_obj_t *lv_obj) {
 #endif  // USE_LVGL_KEYBOARD
 
 void LvglComponent::write_random_() {
-  // length of 2 lines in 32 bit units
+  int iterations = 6 - lv_disp_get_inactive_time(this->disp_) / 60000;
-  // we write 2 lines for the benefit of displays that won't write one line at a time.
+  if (iterations <= 0)
-  size_t line_len = this->disp_drv_.hor_res * LV_COLOR_DEPTH / 8 / 4 * 2;
+    iterations = 1;
-  for (size_t i = 0; i != line_len; i++) {
+  while (iterations-- != 0) {
-    ((uint32_t *) (this->draw_buf_.buf1))[i] = random_uint32();
+    auto col = random_uint32() % this->disp_drv_.hor_res;
+    col = col / this->draw_rounding * this->draw_rounding;
+    auto row = random_uint32() % this->disp_drv_.ver_res;
+    row = row / this->draw_rounding * this->draw_rounding;
+    auto size = (random_uint32() % 32) / this->draw_rounding * this->draw_rounding - 1;
+    lv_area_t area;
+    area.x1 = col;
+    area.y1 = row;
+    area.x2 = col + size;
+    area.y2 = row + size;
+    if (area.x2 >= this->disp_drv_.hor_res)
+      area.x2 = this->disp_drv_.hor_res - 1;
+    if (area.y2 >= this->disp_drv_.ver_res)
+      area.y2 = this->disp_drv_.ver_res - 1;
+
+    size_t line_len = lv_area_get_width(&area) * lv_area_get_height(&area) / 2;
+    for (size_t i = 0; i != line_len; i++) {
+      ((uint32_t *) (this->draw_buf_.buf1))[i] = random_uint32();
+    }
+    this->draw_buffer_(&area, (lv_color_t *) this->draw_buf_.buf1);
   }
-  lv_area_t area;
-  area.x1 = 0;
-  area.x2 = this->disp_drv_.hor_res - 1;
-  if (this->snow_line_ == this->disp_drv_.ver_res / 2) {
-    area.y1 = static_cast<lv_coord_t>(random_uint32() % (this->disp_drv_.ver_res / 2) * 2);
-  } else {
-    area.y1 = this->snow_line_++ * 2;
-  }
-  // write 2 lines
-  area.y2 = area.y1 + 1;
-  this->draw_buffer_(&area, (const uint8_t *) this->draw_buf_.buf1);
 }
 
 void LvglComponent::setup() {
@@ -291,7 +359,7 @@ void LvglComponent::setup() {
   auto *display = this->displays_[0];
   size_t buffer_pixels = display->get_width() * display->get_height() / this->buffer_frac_;
   auto buf_bytes = buffer_pixels * LV_COLOR_DEPTH / 8;
-  auto *buf = lv_custom_mem_alloc(buf_bytes);
+  auto *buf = lv_custom_mem_alloc(buf_bytes);  // NOLINT
   if (buf == nullptr) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_ERROR
     ESP_LOGE(TAG, "Malloc failed to allocate %zu bytes", buf_bytes);
@@ -307,26 +375,30 @@ void LvglComponent::setup() {
   this->disp_drv_.full_refresh = this->full_refresh_;
   this->disp_drv_.flush_cb = static_flush_cb;
   this->disp_drv_.rounder_cb = rounder_cb;
-  switch (display->get_rotation()) {
+  this->rotation = display->get_rotation();
-    case display::DISPLAY_ROTATION_0_DEGREES:
+  if (this->rotation != display::DISPLAY_ROTATION_0_DEGREES) {
-      break;
+    this->rotate_buf_ = static_cast<lv_color_t *>(lv_custom_mem_alloc(buf_bytes));  // NOLINT
-    case display::DISPLAY_ROTATION_90_DEGREES:
+    if (this->rotate_buf_ == nullptr) {
-      this->disp_drv_.sw_rotate = true;
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_ERROR
-      this->disp_drv_.rotated = LV_DISP_ROT_90;
+      ESP_LOGE(TAG, "Malloc failed to allocate %zu bytes", buf_bytes);
-      break;
+#endif
-    case display::DISPLAY_ROTATION_180_DEGREES:
+      this->mark_failed();
-      this->disp_drv_.sw_rotate = true;
+      this->status_set_error("Memory allocation failure");
-      this->disp_drv_.rotated = LV_DISP_ROT_180;
+      return;
-      break;
+    }
-    case display::DISPLAY_ROTATION_270_DEGREES:
-      this->disp_drv_.sw_rotate = true;
-      this->disp_drv_.rotated = LV_DISP_ROT_270;
-      break;
   }
   display->set_rotation(display::DISPLAY_ROTATION_0_DEGREES);
-  this->disp_drv_.hor_res = (lv_coord_t) display->get_width();
+  switch (this->rotation) {
-  this->disp_drv_.ver_res = (lv_coord_t) display->get_height();
+    default:
-  ESP_LOGV(TAG, "sw_rotate = %d, rotated=%d", this->disp_drv_.sw_rotate, this->disp_drv_.rotated);
+      this->disp_drv_.hor_res = (lv_coord_t) display->get_width();
+      this->disp_drv_.ver_res = (lv_coord_t) display->get_height();
+      break;
+    case display::DISPLAY_ROTATION_90_DEGREES:
+    case display::DISPLAY_ROTATION_270_DEGREES:
+      this->disp_drv_.ver_res = (lv_coord_t) display->get_width();
+      this->disp_drv_.hor_res = (lv_coord_t) display->get_height();
+      break;
+  }
   this->disp_ = lv_disp_drv_register(&this->disp_drv_);
   for (const auto &v : this->init_lambdas_)
     v(this);

esphome/components/lvgl/lvgl_esphome.h

@@ -119,6 +119,7 @@ class LvglComponent : public PollingComponent {
   void add_on_idle_callback(std::function<void(uint32_t)> &&callback) {
     this->idle_callbacks_.add(std::move(callback));
   }
+  void add_on_pause_callback(std::function<void(bool)> &&callback) { this->pause_callbacks_.add(std::move(callback)); }
   void add_display(display::Display *display) { this->displays_.push_back(display); }
   void add_init_lambda(const std::function<void(LvglComponent *)> &lamb) { this->init_lambdas_.push_back(lamb); }
   void dump_config() override;
@@ -126,12 +127,22 @@ class LvglComponent : public PollingComponent {
   bool is_idle(uint32_t idle_ms) { return lv_disp_get_inactive_time(this->disp_) > idle_ms; }
   void set_buffer_frac(size_t frac) { this->buffer_frac_ = frac; }
   lv_disp_t *get_disp() { return this->disp_; }
+  // Pause or resume the display.
+  // @param paused If true, pause the display. If false, resume the display.
+  // @param show_snow If true, show the snow effect when paused.
   void set_paused(bool paused, bool show_snow);
+  bool is_paused() const { return this->paused_; }
+  // If the display is paused and we have resume_on_input_ set to true, resume the display.
+  void maybe_wakeup() {
+    if (this->paused_ && this->resume_on_input_) {
+      this->set_paused(false, false);
+    }
+  }
+
   void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event);
   void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2);
   void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
                     lv_event_code_t event3);
-  bool is_paused() const { return this->paused_; }
   void add_page(LvPageType *page);
   void show_page(size_t index, lv_scr_load_anim_t anim, uint32_t time);
   void show_next_page(lv_scr_load_anim_t anim, uint32_t time);
@@ -144,10 +155,17 @@ class LvglComponent : public PollingComponent {
       lv_group_focus_obj(mark);
     }
   }
+  // rounding factor to align bounds of update area when drawing
+  size_t draw_rounding{2};
+  void set_draw_rounding(size_t rounding) { this->draw_rounding = rounding; }
+  void set_resume_on_input(bool resume_on_input) { this->resume_on_input_ = resume_on_input; }
+
+  // if set to true, the bounds of the update area will always start at 0,0
+  display::DisplayRotation rotation{display::DISPLAY_ROTATION_0_DEGREES};
 
  protected:
   void write_random_();
-  void draw_buffer_(const lv_area_t *area, const uint8_t *ptr);
+  void draw_buffer_(const lv_area_t *area, lv_color_t *ptr);
   void flush_cb_(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);
   std::vector<display::Display *> displays_{};
   lv_disp_draw_buf_t draw_buf_{};
@@ -157,14 +175,16 @@ class LvglComponent : public PollingComponent {
   std::vector<LvPageType *> pages_{};
   size_t current_page_{0};
   bool show_snow_{};
-  lv_coord_t snow_line_{};
   bool page_wrap_{true};
+  bool resume_on_input_{};
   std::map<lv_group_t *, lv_obj_t *> focus_marks_{};
 
   std::vector<std::function<void(LvglComponent *lv_component)>> init_lambdas_;
   CallbackManager<void(uint32_t)> idle_callbacks_{};
+  CallbackManager<void(bool)> pause_callbacks_{};
   size_t buffer_frac_{1};
   bool full_refresh_{};
+  lv_color_t *rotate_buf_{};
 };
 
 class IdleTrigger : public Trigger<> {
@@ -176,6 +196,14 @@ class IdleTrigger : public Trigger<> {
   bool is_idle_{};
 };
 
+class PauseTrigger : public Trigger<> {
+ public:
+  explicit PauseTrigger(LvglComponent *parent, TemplatableValue<bool> paused);
+
+ protected:
+  TemplatableValue<bool> paused_;
+};
+
 template<typename... Ts> class LvglAction : public Action<Ts...>, public Parented<LvglComponent> {
  public:
   explicit LvglAction(std::function<void(LvglComponent *)> &&lamb) : action_(std::move(lamb)) {}
@@ -200,7 +228,10 @@ class LVTouchListener : public touchscreen::TouchListener, public Parented<LvglC
  public:
   LVTouchListener(uint16_t long_press_time, uint16_t long_press_repeat_time);
   void update(const touchscreen::TouchPoints_t &tpoints) override;
-  void release() override { touch_pressed_ = false; }
+  void release() override {
+    touch_pressed_ = false;
+    this->parent_->maybe_wakeup();
+  }
   lv_indev_drv_t *get_drv() { return &this->drv_; }
 
  protected:
@@ -236,12 +267,18 @@ class LVEncoderListener : public Parented<LvglComponent> {
     if (!this->parent_->is_paused()) {
       this->pressed_ = pressed;
       this->key_ = key;
+    } else if (!pressed) {
+      // maybe wakeup on release if paused
+      this->parent_->maybe_wakeup();
     }
   }
 
   void set_count(int32_t count) {
-    if (!this->parent_->is_paused())
+    if (!this->parent_->is_paused()) {
       this->count_ = count;
+    } else {
+      this->parent_->maybe_wakeup();
+    }
   }
 
   lv_indev_drv_t *get_drv() { return &this->drv_; }

esphome/components/lvgl/types.py

@@ -40,6 +40,7 @@ lv_event_code_t = cg.global_ns.enum("lv_event_code_t")
 lv_indev_type_t = cg.global_ns.enum("lv_indev_type_t")
 FontEngine = lvgl_ns.class_("FontEngine")
 IdleTrigger = lvgl_ns.class_("IdleTrigger", automation.Trigger.template())
+PauseTrigger = lvgl_ns.class_("PauseTrigger", automation.Trigger.template())
 ObjUpdateAction = lvgl_ns.class_("ObjUpdateAction", automation.Action)
 LvglCondition = lvgl_ns.class_("LvglCondition", automation.Condition)
 LvglAction = lvgl_ns.class_("LvglAction", automation.Action)

esphome/components/max17043/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@blacknell"]

esphome/components/max17043/automation.h

@@ -0,0 +1,20 @@
+
+#pragma once
+#include "esphome/core/automation.h"
+#include "max17043.h"
+
+namespace esphome {
+namespace max17043 {
+
+template<typename... Ts> class SleepAction : public Action<Ts...> {
+ public:
+  explicit SleepAction(MAX17043Component *max17043) : max17043_(max17043) {}
+
+  void play(Ts... x) override { this->max17043_->sleep_mode(); }
+
+ protected:
+  MAX17043Component *max17043_;
+};
+
+}  // namespace max17043
+}  // namespace esphome

esphome/components/max17043/max17043.cpp

@@ -0,0 +1,98 @@
+#include "max17043.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace max17043 {
+
+// MAX174043 is a 1-Cell Fuel Gauge with ModelGauge and Low-Battery Alert
+// Consult the datasheet at https://www.analog.com/en/products/max17043.html
+
+static const char *const TAG = "max17043";
+
+static const uint8_t MAX17043_VCELL = 0x02;
+static const uint8_t MAX17043_SOC = 0x04;
+static const uint8_t MAX17043_CONFIG = 0x0c;
+
+static const uint16_t MAX17043_CONFIG_POWER_UP_DEFAULT = 0x971C;
+static const uint16_t MAX17043_CONFIG_SAFE_MASK = 0xFF1F;  // mask out sleep bit (7), unused bit (6) and alert bit (4)
+static const uint16_t MAX17043_CONFIG_SLEEP_MASK = 0x0080;
+
+void MAX17043Component::update() {
+  uint16_t raw_voltage, raw_percent;
+
+  if (this->voltage_sensor_ != nullptr) {
+    if (!this->read_byte_16(MAX17043_VCELL, &raw_voltage)) {
+      this->status_set_warning("Unable to read MAX17043_VCELL");
+    } else {
+      float voltage = (1.25 * (float) (raw_voltage >> 4)) / 1000.0;
+      this->voltage_sensor_->publish_state(voltage);
+      this->status_clear_warning();
+    }
+  }
+  if (this->battery_remaining_sensor_ != nullptr) {
+    if (!this->read_byte_16(MAX17043_SOC, &raw_percent)) {
+      this->status_set_warning("Unable to read MAX17043_SOC");
+    } else {
+      float percent = (float) ((raw_percent >> 8) + 0.003906f * (raw_percent & 0x00ff));
+      this->battery_remaining_sensor_->publish_state(percent);
+      this->status_clear_warning();
+    }
+  }
+}
+
+void MAX17043Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up MAX17043...");
+
+  uint16_t config_reg;
+  if (this->write(&MAX17043_CONFIG, 1) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+
+  if (this->read(reinterpret_cast<uint8_t *>(&config_reg), 2) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+
+  config_reg = i2c::i2ctohs(config_reg) & MAX17043_CONFIG_SAFE_MASK;
+  ESP_LOGV(TAG, "MAX17043 CONFIG register reads 0x%X", config_reg);
+
+  if (config_reg != MAX17043_CONFIG_POWER_UP_DEFAULT) {
+    ESP_LOGE(TAG, "Device does not appear to be a MAX17043");
+    this->status_set_error("unrecognised");
+    this->mark_failed();
+    return;
+  }
+
+  // need to write back to config register to reset the sleep bit
+  if (!this->write_byte_16(MAX17043_CONFIG, MAX17043_CONFIG_POWER_UP_DEFAULT)) {
+    this->status_set_error("sleep reset failed");
+    this->mark_failed();
+    return;
+  }
+}
+
+void MAX17043Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "MAX17043:");
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with MAX17043 failed");
+  }
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Battery Voltage", this->voltage_sensor_);
+  LOG_SENSOR("  ", "Battery Level", this->battery_remaining_sensor_);
+}
+
+float MAX17043Component::get_setup_priority() const { return setup_priority::DATA; }
+
+void MAX17043Component::sleep_mode() {
+  if (!this->is_failed()) {
+    if (!this->write_byte_16(MAX17043_CONFIG, MAX17043_CONFIG_POWER_UP_DEFAULT | MAX17043_CONFIG_SLEEP_MASK)) {
+      ESP_LOGW(TAG, "Unable to write the sleep bit to config register");
+      this->status_set_warning();
+    }
+  }
+}
+
+}  // namespace max17043
+}  // namespace esphome

esphome/components/max17043/max17043.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace max17043 {
+
+class MAX17043Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+  void update() override;
+  void sleep_mode();
+
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
+  void set_battery_remaining_sensor(sensor::Sensor *battery_remaining_sensor) {
+    battery_remaining_sensor_ = battery_remaining_sensor;
+  }
+
+ protected:
+  sensor::Sensor *voltage_sensor_{nullptr};
+  sensor::Sensor *battery_remaining_sensor_{nullptr};
+};
+
+}  // namespace max17043
+}  // namespace esphome

esphome/components/max17043/sensor.py

@@ -0,0 +1,77 @@
+from esphome import automation
+from esphome.automation import maybe_simple_id
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BATTERY_LEVEL,
+    CONF_BATTERY_VOLTAGE,
+    CONF_ID,
+    DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_VOLTAGE,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_PERCENT,
+    UNIT_VOLT,
+)
+
+DEPENDENCIES = ["i2c"]
+
+max17043_ns = cg.esphome_ns.namespace("max17043")
+MAX17043Component = max17043_ns.class_(
+    "MAX17043Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+# Actions
+SleepAction = max17043_ns.class_("SleepAction", automation.Action)
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(MAX17043Component),
+            cv.Optional(CONF_BATTERY_VOLTAGE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_VOLT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_VOLTAGE,
+                state_class=STATE_CLASS_MEASUREMENT,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+            cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
+                unit_of_measurement=UNIT_PERCENT,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_BATTERY,
+                state_class=STATE_CLASS_MEASUREMENT,
+                entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x36))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if voltage_config := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+
+    if CONF_BATTERY_LEVEL in config:
+        sens = await sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery_remaining_sensor(sens))
+
+
+MAX17043_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(MAX17043Component),
+    }
+)
+
+
+@automation.register_action("max17043.sleep_mode", SleepAction, MAX17043_ACTION_SCHEMA)
+async def max17043_sleep_mode_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/qspi_amoled/display.py

@@ -1,143 +1,3 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome import pins
-from esphome.components import (
-    spi,
-    display,
-)
-from esphome.const import (
-    CONF_RESET_PIN,
-    CONF_ID,
-    CONF_DIMENSIONS,
-    CONF_WIDTH,
-    CONF_HEIGHT,
-    CONF_LAMBDA,
-    CONF_BRIGHTNESS,
-    CONF_ENABLE_PIN,
-    CONF_MODEL,
-    CONF_OFFSET_HEIGHT,
-    CONF_OFFSET_WIDTH,
-    CONF_INVERT_COLORS,
-    CONF_MIRROR_X,
-    CONF_MIRROR_Y,
-    CONF_SWAP_XY,
-    CONF_COLOR_ORDER,
-    CONF_TRANSFORM,
-)
 
-DEPENDENCIES = ["spi"]
+CONFIG_SCHEMA = cv.invalid("The qspi_amoled component has been renamed to qspi_dbi")
-
-qspi_amoled_ns = cg.esphome_ns.namespace("qspi_amoled")
-QSPI_AMOLED = qspi_amoled_ns.class_(
-    "QspiAmoLed", display.Display, display.DisplayBuffer, cg.Component, spi.SPIDevice
-)
-ColorOrder = display.display_ns.enum("ColorMode")
-Model = qspi_amoled_ns.enum("Model")
-
-MODELS = {"RM690B0": Model.RM690B0, "RM67162": Model.RM67162}
-
-COLOR_ORDERS = {
-    "RGB": ColorOrder.COLOR_ORDER_RGB,
-    "BGR": ColorOrder.COLOR_ORDER_BGR,
-}
-DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
-
-
-def validate_dimension(value):
-    value = cv.positive_int(value)
-    if value % 2 != 0:
-        raise cv.Invalid("Width/height/offset must be divisible by 2")
-    return value
-
-
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
-        cv.Schema(
-            {
-                cv.GenerateID(): cv.declare_id(QSPI_AMOLED),
-                cv.Required(CONF_MODEL): cv.enum(MODELS, upper=True),
-                cv.Required(CONF_DIMENSIONS): cv.Any(
-                    cv.dimensions,
-                    cv.Schema(
-                        {
-                            cv.Required(CONF_WIDTH): validate_dimension,
-                            cv.Required(CONF_HEIGHT): validate_dimension,
-                            cv.Optional(
-                                CONF_OFFSET_HEIGHT, default=0
-                            ): validate_dimension,
-                            cv.Optional(
-                                CONF_OFFSET_WIDTH, default=0
-                            ): validate_dimension,
-                        }
-                    ),
-                ),
-                cv.Optional(CONF_TRANSFORM): cv.Schema(
-                    {
-                        cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
-                        cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
-                        cv.Optional(CONF_SWAP_XY, default=False): cv.boolean,
-                    }
-                ),
-                cv.Optional(CONF_COLOR_ORDER, default="RGB"): cv.enum(
-                    COLOR_ORDERS, upper=True
-                ),
-                cv.Optional(CONF_INVERT_COLORS, default=False): cv.boolean,
-                cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
-                cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
-                cv.Optional(CONF_BRIGHTNESS, default=0xD0): cv.int_range(
-                    0, 0xFF, min_included=True, max_included=True
-                ),
-            }
-        ).extend(
-            spi.spi_device_schema(
-                cs_pin_required=False,
-                default_mode="MODE0",
-                default_data_rate=10e6,
-                quad=True,
-            )
-        )
-    ),
-    cv.only_with_esp_idf,
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await display.register_display(var, config)
-    await spi.register_spi_device(var, config)
-
-    cg.add(var.set_color_mode(config[CONF_COLOR_ORDER]))
-    cg.add(var.set_invert_colors(config[CONF_INVERT_COLORS]))
-    cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
-    cg.add(var.set_model(config[CONF_MODEL]))
-    if enable_pin := config.get(CONF_ENABLE_PIN):
-        enable = await cg.gpio_pin_expression(enable_pin)
-        cg.add(var.set_enable_pin(enable))
-
-    if reset_pin := config.get(CONF_RESET_PIN):
-        reset = await cg.gpio_pin_expression(reset_pin)
-        cg.add(var.set_reset_pin(reset))
-
-    if transform := config.get(CONF_TRANSFORM):
-        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
-        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
-        cg.add(var.set_swap_xy(transform[CONF_SWAP_XY]))
-
-    if CONF_DIMENSIONS in config:
-        dimensions = config[CONF_DIMENSIONS]
-        if isinstance(dimensions, dict):
-            cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
-            cg.add(
-                var.set_offsets(
-                    dimensions[CONF_OFFSET_WIDTH], dimensions[CONF_OFFSET_HEIGHT]
-                )
-            )
-        else:
-            (width, height) = dimensions
-            cg.add(var.set_dimensions(width, height))
-
-    if lamb := config.get(CONF_LAMBDA):
-        lambda_ = await cg.process_lambda(
-            lamb, [(display.DisplayRef, "it")], return_type=cg.void
-        )
-        cg.add(var.set_writer(lambda_))

esphome/components/qspi_dbi/display.py

@@ -0,0 +1,185 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import display, spi
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BRIGHTNESS,
+    CONF_COLOR_ORDER,
+    CONF_DIMENSIONS,
+    CONF_ENABLE_PIN,
+    CONF_HEIGHT,
+    CONF_ID,
+    CONF_INIT_SEQUENCE,
+    CONF_INVERT_COLORS,
+    CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_MODEL,
+    CONF_OFFSET_HEIGHT,
+    CONF_OFFSET_WIDTH,
+    CONF_RESET_PIN,
+    CONF_SWAP_XY,
+    CONF_TRANSFORM,
+    CONF_WIDTH,
+)
+from esphome.core import TimePeriod
+
+from .models import DriverChip
+
+DEPENDENCIES = ["spi"]
+
+qspi_dbi_ns = cg.esphome_ns.namespace("qspi_dbi")
+QSPI_DBI = qspi_dbi_ns.class_(
+    "QspiDbi", display.Display, display.DisplayBuffer, cg.Component, spi.SPIDevice
+)
+ColorOrder = display.display_ns.enum("ColorMode")
+Model = qspi_dbi_ns.enum("Model")
+
+COLOR_ORDERS = {
+    "RGB": ColorOrder.COLOR_ORDER_RGB,
+    "BGR": ColorOrder.COLOR_ORDER_BGR,
+}
+DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
+
+CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
+DELAY_FLAG = 0xFF
+
+
+def validate_dimension(value):
+    value = cv.positive_int(value)
+    if value % 2 != 0:
+        raise cv.Invalid("Width/height/offset must be divisible by 2")
+    return value
+
+
+def map_sequence(value):
+    """
+    The format is a repeated sequence of [CMD, <data>] where <data> is s a sequence of bytes. The length is inferred
+    from the length of the sequence and should not be explicit.
+    A delay can be inserted by specifying "- delay N" where N is in ms
+    """
+    if isinstance(value, str) and value.lower().startswith("delay "):
+        value = value.lower()[6:]
+        delay = cv.All(
+            cv.positive_time_period_milliseconds,
+            cv.Range(TimePeriod(milliseconds=1), TimePeriod(milliseconds=255)),
+        )(value)
+        return [delay, DELAY_FLAG]
+    value = cv.Length(min=1, max=254)(value)
+    params = value[1:]
+    return [value[0], len(params)] + list(params)
+
+
+def _validate(config):
+    chip = DriverChip.chips[config[CONF_MODEL]]
+    if not chip.initsequence:
+        if CONF_INIT_SEQUENCE not in config:
+            raise cv.Invalid(f"{chip.name} model requires init_sequence")
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        cv.Schema(
+            {
+                cv.GenerateID(): cv.declare_id(QSPI_DBI),
+                cv.Required(CONF_MODEL): cv.one_of(
+                    *DriverChip.chips.keys(), upper=True
+                ),
+                cv.Optional(CONF_INIT_SEQUENCE): cv.ensure_list(map_sequence),
+                cv.Required(CONF_DIMENSIONS): cv.Any(
+                    cv.dimensions,
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_WIDTH): validate_dimension,
+                            cv.Required(CONF_HEIGHT): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_HEIGHT, default=0
+                            ): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_WIDTH, default=0
+                            ): validate_dimension,
+                        }
+                    ),
+                ),
+                cv.Optional(CONF_TRANSFORM): cv.Schema(
+                    {
+                        cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
+                        cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
+                        cv.Optional(CONF_SWAP_XY, default=False): cv.boolean,
+                    }
+                ),
+                cv.Optional(CONF_COLOR_ORDER, default="RGB"): cv.enum(
+                    COLOR_ORDERS, upper=True
+                ),
+                cv.Optional(CONF_INVERT_COLORS, default=False): cv.boolean,
+                cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+                cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
+                cv.Optional(CONF_BRIGHTNESS, default=0xD0): cv.int_range(
+                    0, 0xFF, min_included=True, max_included=True
+                ),
+                cv.Optional(CONF_DRAW_FROM_ORIGIN, default=False): cv.boolean,
+            }
+        ).extend(
+            spi.spi_device_schema(
+                cs_pin_required=False,
+                default_mode="MODE0",
+                default_data_rate=10e6,
+                quad=True,
+            )
+        )
+    ),
+    cv.only_with_esp_idf,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await display.register_display(var, config)
+    await spi.register_spi_device(var, config)
+
+    chip = DriverChip.chips[config[CONF_MODEL]]
+    if chip.initsequence:
+        cg.add(var.add_init_sequence(chip.initsequence))
+    if init_sequences := config.get(CONF_INIT_SEQUENCE):
+        sequence = []
+        for seq in init_sequences:
+            sequence.extend(seq)
+        cg.add(var.add_init_sequence(sequence))
+
+    cg.add(var.set_color_mode(config[CONF_COLOR_ORDER]))
+    cg.add(var.set_invert_colors(config[CONF_INVERT_COLORS]))
+    cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
+    cg.add(var.set_model(config[CONF_MODEL]))
+    cg.add(var.set_draw_from_origin(config[CONF_DRAW_FROM_ORIGIN]))
+    if enable_pin := config.get(CONF_ENABLE_PIN):
+        enable = await cg.gpio_pin_expression(enable_pin)
+        cg.add(var.set_enable_pin(enable))
+
+    if reset_pin := config.get(CONF_RESET_PIN):
+        reset = await cg.gpio_pin_expression(reset_pin)
+        cg.add(var.set_reset_pin(reset))
+
+    if transform := config.get(CONF_TRANSFORM):
+        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
+        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
+        cg.add(var.set_swap_xy(transform[CONF_SWAP_XY]))
+
+    if CONF_DIMENSIONS in config:
+        dimensions = config[CONF_DIMENSIONS]
+        if isinstance(dimensions, dict):
+            cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
+            cg.add(
+                var.set_offsets(
+                    dimensions[CONF_OFFSET_WIDTH], dimensions[CONF_OFFSET_HEIGHT]
+                )
+            )
+        else:
+            (width, height) = dimensions
+            cg.add(var.set_dimensions(width, height))
+
+    if lamb := config.get(CONF_LAMBDA):
+        lambda_ = await cg.process_lambda(
+            lamb, [(display.DisplayRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))

esphome/components/qspi_dbi/models.py

@@ -0,0 +1,64 @@
+# Commands
+SW_RESET_CMD = 0x01
+SLEEP_OUT = 0x11
+INVERT_OFF = 0x20
+INVERT_ON = 0x21
+ALL_ON = 0x23
+WRAM = 0x24
+MIPI = 0x26
+DISPLAY_OFF = 0x28
+DISPLAY_ON = 0x29
+RASET = 0x2B
+CASET = 0x2A
+WDATA = 0x2C
+TEON = 0x35
+MADCTL_CMD = 0x36
+PIXFMT = 0x3A
+BRIGHTNESS = 0x51
+SWIRE1 = 0x5A
+SWIRE2 = 0x5B
+PAGESEL = 0xFE
+
+
+class DriverChip:
+    chips = {}
+
+    def __init__(self, name: str):
+        name = name.upper()
+        self.name = name
+        self.chips[name] = self
+        self.initsequence = []
+
+    def cmd(self, c, *args):
+        """
+        Add a command sequence to the init sequence
+        :param c: The command (8 bit)
+        :param args: zero or more arguments (8 bit values)
+        """
+        self.initsequence.extend([c, len(args)] + list(args))
+
+    def delay(self, ms):
+        self.initsequence.extend([ms, 0xFF])
+
+
+chip = DriverChip("RM67162")
+chip.cmd(PIXFMT, 0x55)
+chip.cmd(BRIGHTNESS, 0)
+
+chip = DriverChip("RM690B0")
+chip.cmd(PAGESEL, 0x20)
+chip.cmd(MIPI, 0x0A)
+chip.cmd(WRAM, 0x80)
+chip.cmd(SWIRE1, 0x51)
+chip.cmd(SWIRE2, 0x2E)
+chip.cmd(PAGESEL, 0x00)
+chip.cmd(0xC2, 0x00)
+chip.delay(10)
+chip.cmd(TEON, 0x00)
+
+chip = DriverChip("AXS15231")
+chip.cmd(0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5)
+chip.cmd(0xC1, 0x33)
+chip.cmd(0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
+
+DriverChip("Custom")

esphome/components/qspi_dbi/qspi_dbi.cpp

@@ -1,12 +1,12 @@
 #ifdef USE_ESP_IDF
-#include "qspi_amoled.h"
+#include "qspi_dbi.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
-namespace qspi_amoled {
+namespace qspi_dbi {
 
-void QspiAmoLed::setup() {
+void QspiDbi::setup() {
-  esph_log_config(TAG, "Setting up QSPI_AMOLED");
+  ESP_LOGCONFIG(TAG, "Setting up QSPI_DBI");
   this->spi_setup();
   if (this->enable_pin_ != nullptr) {
     this->enable_pin_->setup();
@@ -22,13 +22,17 @@ void QspiAmoLed::setup() {
   }
   this->set_timeout(120, [this] { this->write_command_(SLEEP_OUT); });
   this->set_timeout(240, [this] { this->write_init_sequence_(); });
+  if (this->draw_from_origin_)
+    check_buffer_();
 }
 
-void QspiAmoLed::update() {
+void QspiDbi::update() {
   if (!this->setup_complete_) {
     return;
   }
   this->do_update_();
+  if (this->buffer_ == nullptr || this->x_low_ > this->x_high_ || this->y_low_ > this->y_high_)
+    return;
   // Start addresses and widths/heights must be divisible by 2 (CASET/RASET restriction in datasheet)
   if (this->x_low_ % 2 == 1) {
     this->x_low_--;
@@ -42,10 +46,15 @@ void QspiAmoLed::update() {
   if (this->y_high_ % 2 == 0) {
     this->y_high_++;
   }
+  if (this->draw_from_origin_) {
+    this->x_low_ = 0;
+    this->y_low_ = 0;
+    this->x_high_ = this->width_ - 1;
+  }
   int w = this->x_high_ - this->x_low_ + 1;
   int h = this->y_high_ - this->y_low_ + 1;
-  this->draw_pixels_at(this->x_low_, this->y_low_, w, h, this->buffer_, this->color_mode_, display::COLOR_BITNESS_565,
+  this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_, this->y_low_,
-                       true, this->x_low_, this->y_low_, this->get_width_internal() - w - this->x_low_);
+                          this->width_ - w - this->x_low_);
   // invalidate watermarks
   this->x_low_ = this->width_;
   this->y_low_ = this->height_;
@@ -53,21 +62,19 @@ void QspiAmoLed::update() {
   this->y_high_ = 0;
 }
 
-void QspiAmoLed::draw_absolute_pixel_internal(int x, int y, Color color) {
+void QspiDbi::draw_absolute_pixel_internal(int x, int y, Color color) {
   if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0) {
     return;
   }
-  if (this->buffer_ == nullptr)
-    this->init_internal_(this->width_ * this->height_ * 2);
   if (this->is_failed())
     return;
+  check_buffer_();
   uint32_t pos = (y * this->width_) + x;
-  uint16_t new_color;
   bool updated = false;
   pos = pos * 2;
-  new_color = display::ColorUtil::color_to_565(color, display::ColorOrder::COLOR_ORDER_RGB);
+  uint16_t new_color = display::ColorUtil::color_to_565(color, display::ColorOrder::COLOR_ORDER_RGB);
-  if (this->buffer_[pos] != (uint8_t) (new_color >> 8)) {
+  if (this->buffer_[pos] != static_cast<uint8_t>(new_color >> 8)) {
-    this->buffer_[pos] = (uint8_t) (new_color >> 8);
+    this->buffer_[pos] = static_cast<uint8_t>(new_color >> 8);
     updated = true;
   }
   pos = pos + 1;
@@ -90,7 +97,7 @@ void QspiAmoLed::draw_absolute_pixel_internal(int x, int y, Color color) {
   }
 }
 
-void QspiAmoLed::reset_params_(bool ready) {
+void QspiDbi::reset_params_(bool ready) {
   if (!ready && !this->is_ready())
     return;
   this->write_command_(this->invert_colors_ ? INVERT_ON : INVERT_OFF);
@@ -102,55 +109,64 @@ void QspiAmoLed::reset_params_(bool ready) {
     mad |= MADCTL_MX;
   if (this->mirror_y_)
     mad |= MADCTL_MY;
-  this->write_command_(MADCTL_CMD, &mad, 1);
+  this->write_command_(MADCTL_CMD, mad);
-  this->write_command_(BRIGHTNESS, &this->brightness_, 1);
+  this->write_command_(BRIGHTNESS, this->brightness_);
+  this->write_command_(NORON);
+  this->write_command_(DISPLAY_ON);
 }
 
-void QspiAmoLed::write_init_sequence_() {
+void QspiDbi::write_init_sequence_() {
-  if (this->model_ == RM690B0) {
+  for (const auto &seq : this->init_sequences_) {
-    this->write_command_(PAGESEL, 0x20);
+    this->write_sequence_(seq);
-    this->write_command_(MIPI, 0x0A);
-    this->write_command_(WRAM, 0x80);
-    this->write_command_(SWIRE1, 0x51);
-    this->write_command_(SWIRE2, 0x2E);
-    this->write_command_(PAGESEL, 0x00);
-    this->write_command_(0xC2, 0x00);
-    delay(10);
-    this->write_command_(TEON, 0x00);
   }
-  this->write_command_(PIXFMT, 0x55);
-  this->write_command_(BRIGHTNESS, 0);
-  this->write_command_(DISPLAY_ON);
   this->reset_params_(true);
   this->setup_complete_ = true;
-  esph_log_config(TAG, "QSPI_AMOLED setup complete");
+  ESP_LOGCONFIG(TAG, "QSPI_DBI setup complete");
 }
 
-void QspiAmoLed::set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
+void QspiDbi::set_addr_window_(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
+  ESP_LOGVV(TAG, "Set addr %d/%d, %d/%d", x1, y1, x2, y2);
   uint8_t buf[4];
   x1 += this->offset_x_;
   x2 += this->offset_x_;
   y1 += this->offset_y_;
   y2 += this->offset_y_;
-  put16_be(buf, x1);
-  put16_be(buf + 2, x2);
-  this->write_command_(CASET, buf, sizeof buf);
   put16_be(buf, y1);
   put16_be(buf + 2, y2);
   this->write_command_(RASET, buf, sizeof buf);
+  put16_be(buf, x1);
+  put16_be(buf + 2, x2);
+  this->write_command_(CASET, buf, sizeof buf);
 }
 
-void QspiAmoLed::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
+void QspiDbi::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
-                                display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+                             display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
   if (!this->setup_complete_ || this->is_failed())
     return;
   if (w <= 0 || h <= 0)
     return;
   if (bitness != display::COLOR_BITNESS_565 || order != this->color_mode_ ||
       big_endian != (this->bit_order_ == spi::BIT_ORDER_MSB_FIRST)) {
-    return display::Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset,
+    return Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
-                                            x_pad);
+  } else if (this->draw_from_origin_) {
+    auto stride = x_offset + w + x_pad;
+    for (int y = 0; y != h; y++) {
+      memcpy(this->buffer_ + ((y + y_start) * this->width_ + x_start) * 2,
+             ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2);
+    }
+    ptr = this->buffer_;
+    w = this->width_;
+    h += y_start;
+    x_start = 0;
+    y_start = 0;
+    x_offset = 0;
+    y_offset = 0;
   }
+  this->write_to_display_(x_start, y_start, w, h, ptr, x_offset, y_offset, x_pad);
+}
+
+void QspiDbi::write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
+                                int x_pad) {
   this->set_addr_window_(x_start, y_start, x_start + w - 1, y_start + h - 1);
   this->enable();
   // x_ and y_offset are offsets into the source buffer, unrelated to our own offsets into the display.
@@ -158,17 +174,50 @@ void QspiAmoLed::draw_pixels_at(int x_start, int y_start, int w, int h, const ui
     // we could deal here with a non-zero y_offset, but if x_offset is zero, y_offset probably will be so don't bother
     this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, ptr, w * h * 2, 4);
   } else {
-    this->write_cmd_addr_data(8, 0x32, 24, 0x2C00, nullptr, 0, 4);
     auto stride = x_offset + w + x_pad;
+    uint16_t cmd = 0x2C00;
     for (int y = 0; y != h; y++) {
-      this->write_cmd_addr_data(0, 0, 0, 0, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
+      this->write_cmd_addr_data(8, 0x32, 24, cmd, ptr + ((y + y_offset) * stride + x_offset) * 2, w * 2, 4);
+      cmd = 0x3C00;
     }
   }
   this->disable();
 }
+void QspiDbi::write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
+  ESP_LOGV(TAG, "Command %02X, length %d, bytes %s", cmd, len, format_hex_pretty(bytes, len).c_str());
+  this->enable();
+  this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
+  this->disable();
+}
 
-void QspiAmoLed::dump_config() {
+void QspiDbi::write_sequence_(const std::vector<uint8_t> &vec) {
-  ESP_LOGCONFIG("", "QSPI AMOLED");
+  size_t index = 0;
+  while (index != vec.size()) {
+    if (vec.size() - index < 2) {
+      ESP_LOGE(TAG, "Malformed init sequence");
+      return;
+    }
+    uint8_t cmd = vec[index++];
+    uint8_t x = vec[index++];
+    if (x == DELAY_FLAG) {
+      ESP_LOGV(TAG, "Delay %dms", cmd);
+      delay(cmd);
+    } else {
+      uint8_t num_args = x & 0x7F;
+      if (vec.size() - index < num_args) {
+        ESP_LOGE(TAG, "Malformed init sequence");
+        return;
+      }
+      const auto *ptr = vec.data() + index;
+      this->write_command_(cmd, ptr, num_args);
+      index += num_args;
+    }
+  }
+}
+
+void QspiDbi::dump_config() {
+  ESP_LOGCONFIG("", "QSPI_DBI Display");
+  ESP_LOGCONFIG("", "Model: %s", this->model_);
   ESP_LOGCONFIG(TAG, "  Height: %u", this->height_);
   ESP_LOGCONFIG(TAG, "  Width: %u", this->width_);
   LOG_PIN("  CS Pin: ", this->cs_);
@@ -176,6 +225,6 @@ void QspiAmoLed::dump_config() {
   ESP_LOGCONFIG(TAG, "  SPI Data rate: %dMHz", (unsigned) (this->data_rate_ / 1000000));
 }
 
-}  // namespace qspi_amoled
+}  // namespace qspi_dbi
 }  // namespace esphome
 #endif

esphome/components/qspi_dbi/qspi_dbi.h

@@ -14,11 +14,12 @@
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome {
-namespace qspi_amoled {
+namespace qspi_dbi {
 
-constexpr static const char *const TAG = "display.qspi_amoled";
+constexpr static const char *const TAG = "display.qspi_dbi";
 static const uint8_t SW_RESET_CMD = 0x01;
 static const uint8_t SLEEP_OUT = 0x11;
+static const uint8_t NORON = 0x13;
 static const uint8_t INVERT_OFF = 0x20;
 static const uint8_t INVERT_ON = 0x21;
 static const uint8_t ALL_ON = 0x23;
@@ -42,6 +43,7 @@ static const uint8_t MADCTL_MV = 0x20;   ///< Bit 5 Reverse Mode
 static const uint8_t MADCTL_RGB = 0x00;  ///< Bit 3 Red-Green-Blue pixel order
 static const uint8_t MADCTL_BGR = 0x08;  ///< Bit 3 Blue-Green-Red pixel order
 
+static const uint8_t DELAY_FLAG = 0xFF;
 // store a 16 bit value in a buffer, big endian.
 static inline void put16_be(uint8_t *buf, uint16_t value) {
   buf[0] = value >> 8;
@@ -49,15 +51,16 @@ static inline void put16_be(uint8_t *buf, uint16_t value) {
 }
 
 enum Model {
+  CUSTOM,
   RM690B0,
   RM67162,
 };
 
-class QspiAmoLed : public display::DisplayBuffer,
+class QspiDbi : public display::DisplayBuffer,
-                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
+                public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
-                                         spi::DATA_RATE_1MHZ> {
+                                      spi::DATA_RATE_1MHZ> {
  public:
-  void set_model(Model model) { this->model_ = model; }
+  void set_model(const char *model) { this->model_ = model; }
   void update() override;
   void setup() override;
   display::ColorOrder get_color_mode() { return this->color_mode_; }
@@ -93,17 +96,27 @@ class QspiAmoLed : public display::DisplayBuffer,
     this->offset_x_ = offset_x;
     this->offset_y_ = offset_y;
   }
+
+  void set_draw_from_origin(bool draw_from_origin) { this->draw_from_origin_ = draw_from_origin; }
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
   void dump_config() override;
 
   int get_width_internal() override { return this->width_; }
   int get_height_internal() override { return this->height_; }
   bool can_proceed() override { return this->setup_complete_; }
+  void add_init_sequence(const std::vector<uint8_t> &sequence) { this->init_sequences_.push_back(sequence); }
 
  protected:
+  void check_buffer_() {
+    if (this->buffer_ == nullptr)
+      this->init_internal_(this->width_ * this->height_ * 2);
+  }
+  void write_sequence_(const std::vector<uint8_t> &vec);
   void draw_absolute_pixel_internal(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, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
+  void write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
+                         int x_pad);
   /**
    * the RM67162 in quad SPI mode seems to work like this (not in the datasheet, this is deduced from the
    * sample code.)
@@ -122,11 +135,7 @@ class QspiAmoLed : public display::DisplayBuffer,
    * @param bytes
    * @param len
    */
-  void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len) {
+  void write_command_(uint8_t cmd, const uint8_t *bytes, size_t len);
-    this->enable();
-    this->write_cmd_addr_data(8, 0x02, 24, cmd << 8, bytes, len);
-    this->disable();
-  }
 
   void write_command_(uint8_t cmd, uint8_t data) { this->write_command_(cmd, &data, 1); }
   void write_command_(uint8_t cmd) { this->write_command_(cmd, &cmd, 0); }
@@ -136,8 +145,8 @@ class QspiAmoLed : public display::DisplayBuffer,
 
   GPIOPin *reset_pin_{nullptr};
   GPIOPin *enable_pin_{nullptr};
-  uint16_t x_low_{0};
+  uint16_t x_low_{1};
-  uint16_t y_low_{0};
+  uint16_t y_low_{1};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
   bool setup_complete_{};
@@ -151,12 +160,14 @@ class QspiAmoLed : public display::DisplayBuffer,
   bool swap_xy_{};
   bool mirror_x_{};
   bool mirror_y_{};
+  bool draw_from_origin_{false};
   uint8_t brightness_{0xD0};
-  Model model_{RM690B0};
+  const char *model_{"Unknown"};
+  std::vector<std::vector<uint8_t>> init_sequences_{};
 
   esp_lcd_panel_handle_t handle_{};
 };
 
-}  // namespace qspi_amoled
+}  // namespace qspi_dbi
 }  // namespace esphome
 #endif

esphome/components/st7701s/display.py

@@ -18,6 +18,7 @@ from esphome.const import (
     CONF_HSYNC_PIN,
     CONF_ID,
     CONF_IGNORE_STRAPPING_WARNING,
+    CONF_INIT_SEQUENCE,
     CONF_INVERT_COLORS,
     CONF_LAMBDA,
     CONF_MIRROR_X,
@@ -35,7 +36,6 @@ from esphome.core import TimePeriod
 
 from .init_sequences import ST7701S_INITS, cmd
 
-CONF_INIT_SEQUENCE = "init_sequence"
 CONF_DE_PIN = "de_pin"
 CONF_PCLK_PIN = "pclk_pin"
 

esphome/components/statsd/statsd.cpp

@@ -2,6 +2,7 @@
 
 #include "statsd.h"
 
+#ifdef USE_NETWORK
 namespace esphome {
 namespace statsd {
 
@@ -154,3 +155,4 @@ void StatsdComponent::send_(std::string *out) {
 
 }  // namespace statsd
 }  // namespace esphome
+#endif

esphome/components/statsd/statsd.h

@@ -3,6 +3,7 @@
 #include <vector>
 
 #include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include "esphome/core/component.h"
 #include "esphome/components/socket/socket.h"
 #include "esphome/components/network/ip_address.h"
@@ -84,3 +85,4 @@ class StatsdComponent : public PollingComponent {
 
 }  // namespace statsd
 }  // namespace esphome
+#endif

esphome/components/tc74/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@sethgirvan"]

esphome/components/tc74/sensor.py

@@ -0,0 +1,32 @@
+import esphome.codegen as cg
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+)
+
+CODEOWNERS = ["@sethgirvan"]
+DEPENDENCIES = ["i2c"]
+
+tc74_ns = cg.esphome_ns.namespace("tc74")
+TC74Component = tc74_ns.class_("TC74Component", cg.PollingComponent, i2c.I2CDevice)
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(
+        TC74Component,
+        unit_of_measurement=UNIT_CELSIUS,
+        accuracy_decimals=1,
+        device_class=DEVICE_CLASS_TEMPERATURE,
+        state_class=STATE_CLASS_MEASUREMENT,
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x48))
+)
+
+
+async def to_code(config):
+    var = await sensor.new_sensor(config)
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)

esphome/components/tc74/tc74.cpp

@@ -0,0 +1,68 @@
+// Based on the TC74 datasheet https://ww1.microchip.com/downloads/en/DeviceDoc/21462D.pdf
+
+#include "tc74.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace tc74 {
+
+static const char *const TAG = "tc74";
+
+static const uint8_t TC74_REGISTER_TEMPERATURE = 0x00;
+static const uint8_t TC74_REGISTER_CONFIGURATION = 0x01;
+static const uint8_t TC74_DATA_READY_MASK = 0x40;
+
+// It is possible the "Data Ready" bit will not be set if the TC74 has not been powered on for at least 250ms, so it not
+// being set does not constitute a failure.
+void TC74Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up TC74...");
+  uint8_t config_reg;
+  if (this->read_register(TC74_REGISTER_CONFIGURATION, &config_reg, 1) != i2c::ERROR_OK) {
+    this->mark_failed();
+    return;
+  }
+  this->data_ready_ = config_reg & TC74_DATA_READY_MASK;
+}
+
+void TC74Component::update() { this->read_temperature_(); }
+
+void TC74Component::dump_config() {
+  LOG_SENSOR("", "TC74", this);
+  LOG_I2C_DEVICE(this);
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Connection with TC74 failed!");
+  }
+  LOG_UPDATE_INTERVAL(this);
+}
+
+void TC74Component::read_temperature_() {
+  if (!this->data_ready_) {
+    uint8_t config_reg;
+    if (this->read_register(TC74_REGISTER_CONFIGURATION, &config_reg, 1) != i2c::ERROR_OK) {
+      this->status_set_warning();
+      return;
+    }
+
+    if (config_reg & TC74_DATA_READY_MASK) {
+      this->data_ready_ = true;
+    } else {
+      ESP_LOGD(TAG, "TC74 not ready");
+      return;
+    }
+  }
+
+  uint8_t temperature_reg;
+  if (this->read_register(TC74_REGISTER_TEMPERATURE, &temperature_reg, 1) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
+  }
+
+  ESP_LOGD(TAG, "Got Temperature=%d °C", temperature_reg);
+  this->publish_state(temperature_reg);
+  this->status_clear_warning();
+}
+
+float TC74Component::get_setup_priority() const { return setup_priority::DATA; }
+
+}  // namespace tc74
+}  // namespace esphome

esphome/components/tc74/tc74.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome {
+namespace tc74 {
+
+class TC74Component : public PollingComponent, public i2c::I2CDevice, public sensor::Sensor {
+ public:
+  /// Setup the sensor and check connection.
+  void setup() override;
+  void dump_config() override;
+  /// Update the sensor value (temperature).
+  void update() override;
+
+  float get_setup_priority() const override;
+
+ protected:
+  /// Internal method to read the temperature from the component after it has been scheduled.
+  void read_temperature_();
+
+  bool data_ready_ = false;
+};
+
+}  // namespace tc74
+}  // namespace esphome

esphome/const.py

@@ -49,6 +49,7 @@ CONF_ADDRESS = "address"
 CONF_ADDRESSABLE_LIGHT_ID = "addressable_light_id"
 CONF_ADVANCED = "advanced"
 CONF_AFTER = "after"
+CONF_ALL = "all"
 CONF_ALLOW_OTHER_USES = "allow_other_uses"
 CONF_ALPHA = "alpha"
 CONF_ALTITUDE = "altitude"
@@ -57,6 +58,7 @@ CONF_AMMONIA = "ammonia"
 CONF_ANALOG = "analog"
 CONF_AND = "and"
 CONF_ANGLE = "angle"
+CONF_ANY = "any"
 CONF_AP = "ap"
 CONF_APPARENT_POWER = "apparent_power"
 CONF_ARDUINO_VERSION = "arduino_version"
@@ -396,6 +398,7 @@ CONF_INCLUDES = "includes"
 CONF_INDEX = "index"
 CONF_INDOOR = "indoor"
 CONF_INFRARED = "infrared"
+CONF_INIT_SEQUENCE = "init_sequence"
 CONF_INITIAL_MODE = "initial_mode"
 CONF_INITIAL_OPTION = "initial_option"
 CONF_INITIAL_STATE = "initial_state"

requirements.txt

@@ -1,7 +1,7 @@
 async_timeout==4.0.3; python_version <= "3.10"
 cryptography==43.0.0
 voluptuous==0.14.2
-PyYAML==6.0.1
+PyYAML==6.0.2
 paho-mqtt==1.6.1
 colorama==0.4.6
 icmplib==3.0.4
@@ -9,7 +9,7 @@ tornado==6.4
 tzlocal==5.2    # from time
 tzdata>=2021.1  # from time
 pyserial==3.5
-platformio==6.1.15  # When updating platformio, also update Dockerfile
+platformio==6.1.16  # When updating platformio, also update Dockerfile
 esptool==4.7.0
 click==8.1.7
 esphome-dashboard==20240620.0

tests/components/display/common.yaml

@@ -34,3 +34,7 @@ display:
 
         it.line_at_angle(centerX, centerY, minuteAngle, radius - 5, radius);
       }
+
+      // Nice ring around and some gauge
+      it.filled_ring(centerX, centerY, radius+5, radius+8);
+      it.filled_gauge(centerX, centerY, radius/2, radius/2-5, 66);

tests/components/lvgl/lvgl-package.yaml

@@ -12,6 +12,11 @@ substitutions:
   arrow_down: "\U000F004B"
 
 lvgl:
+  resume_on_input: true
+  on_pause:
+    logger.log: LVGL is Paused
+  on_resume:
+    logger.log: LVGL has resumed
   log_level: TRACE
   bg_color: light_blue
   disp_bg_color: color_id

tests/components/lvgl/test.esp32-ard.yaml

@@ -44,6 +44,7 @@ binary_sensor:
       number: GPIO39
       inverted: true
 lvgl:
+  draw_rounding: 8
   encoders:
     group: switches
     initial_focus: button_button

tests/components/max17043/common.yaml

@@ -0,0 +1,19 @@
+esphome:
+  on_boot:
+    then:
+      - max17043.sleep_mode: max17043_id
+
+i2c:
+  - id: i2c_id
+    scl: ${scl_pin}
+    sda: ${sda_pin}
+
+sensor:
+  - platform: max17043
+    id: max17043_id
+    i2c_id: i2c_id
+    battery_voltage:
+      name: "Battery Voltage"
+    battery_level:
+      name: Battery
+    update_interval: 10s

tests/components/max17043/test.esp32-ard.yaml

@@ -0,0 +1,6 @@
+substitutions:
+  sda_pin: GPIO21
+  scl_pin: GPIO22
+
+<<: !include common.yaml
+

tests/components/max17043/test.esp32-c3-ard.yaml

@@ -0,0 +1,5 @@
+substitutions:
+  sda_pin: GPIO8
+  scl_pin: GPIO10
+
+<<: !include common.yaml

tests/components/max17043/test.esp32-c3-idf.yaml

@@ -0,0 +1,5 @@
+substitutions:
+  sda_pin: GPIO8
+  scl_pin: GPIO10
+
+<<: !include common.yaml

tests/components/max17043/test.esp32-idf.yaml

@@ -0,0 +1,5 @@
+substitutions:
+  sda_pin: GPIO21
+  scl_pin: GPIO22
+
+<<: !include common.yaml

tests/components/max17043/test.esp8266-ard.yaml

@@ -0,0 +1,5 @@
+substitutions:
+  sda_pin: GPIO4
+  scl_pin: GPIO5
+
+<<: !include common.yaml

tests/components/max17043/test.rp2040-ard.yaml

@@ -0,0 +1,5 @@
+substitutions:
+  sda_pin: GPIO21
+  scl_pin: GPIO22
+
+<<: !include common.yaml

tests/components/qspi_dbi/common.yaml

@@ -5,7 +5,7 @@ spi:
   data_pins: [14, 10, 16, 12]
 
 display:
-  - platform: qspi_amoled
+  - platform: qspi_dbi
     model: RM690B0
     data_rate: 80MHz
     spi_mode: mode0
@@ -20,9 +20,10 @@ display:
     reset_pin: 13
     enable_pin: 9
 
-  - platform: qspi_amoled
+  - platform: qspi_dbi
-    model: RM67162
+    model: CUSTOM
     id: main_lcd
+    draw_from_origin: true
     dimensions:
       height: 240
       width: 536
@@ -34,3 +35,10 @@ display:
     cs_pin: 6
     reset_pin: 17
     enable_pin: 38
+    init_sequence:
+      - [0x3A, 0x66]
+      - [0x11]
+      - delay 120ms
+      - [0x29]
+      - delay 20ms
+

tests/components/tc74/test.esp32-ard.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 16
+    sda: 17
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature

tests/components/tc74/test.esp32-c3-ard.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 5
+    sda: 4
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature

tests/components/tc74/test.esp32-c3-idf.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 5
+    sda: 4
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature

tests/components/tc74/test.esp32-idf.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 16
+    sda: 17
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature

tests/components/tc74/test.esp8266-ard.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 5
+    sda: 4
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature

tests/components/tc74/test.rp2040-ard.yaml

@@ -0,0 +1,8 @@
+i2c:
+  - id: i2c_tc74
+    scl: 5
+    sda: 4
+
+sensor:
+  - platform: tc74
+    name: TC74 Temperature