WT32-SC01 Plus + Arduino + V9 Widget Demo struggle

What MCU/Processor/Board and compiler are you using?

  • WT32-SC01 Plus
  • Arduino 1.8 using Visual Micro
  • LVGL v9.2.2

The WT32-SC01 Plus uses a 320x480px RGB LCD using a ST7796U controller 8080 interface(I am not exactly sure what 8080 means)
Datasheet for the dev board: Here

Touch screen uses FT6336U I2C interface.

What do you want to achieve?

Right now I am just trying to get the basic demo_widgets demo to display, then get the touch working

Code to reproduce

I have been working towards something functional and this is my best attempt so far:

Since the lv_conf contains a section for ST7796U shouldn’t there be a way to define the parallel interface rather than writing a driver? I am a bit unclear on if the below flush function will work, found it online but can’t seem to find the source now. Should I be using something like LGFX to handle the actual writing to the display? Even so, the error I am getting about theming would be an issue.

lv_conf.h too long to post, if it is necessary I can post it cut up into parts

#include <lvgl.h>
#include <demos/lv_demos.h>
#include <examples/lv_examples.h>
#include <SPI.h>

// Define parallel pins (adjust based on your wiring)

#define screenWidth 480
#define screenHeight 320

#define BL_PWM 45

#define TFT_D0 9
#define TFT_D1 46
#define TFT_D2 3
#define TFT_D3 8
#define TFT_D4 18
#define TFT_D5 17
#define TFT_D6 16
#define TFT_D7 15
// Write Clock
#define TFT_WR 47
// Frame Sync
#define TFT_FSYNC 48
// Reset
#define TFT_RST 4
// Data/Command
#define TFT_DC 0

const unsigned int lvBufferSize = screenWidth * screenHeight / 10 * (LV_COLOR_DEPTH / 8);
uint8_t lvBuffer[lvBufferSize];

void setup() {
    Serial.begin(115200);


    pinMode(BL_PWM, OUTPUT);
    analogWrite(BL_PWM, 200);


    lv_init(); // Initialize LVGL

    static lv_display_t* display = lv_display_create(screenWidth, screenHeight);
    lv_display_set_color_format(display, LV_COLOR_FORMAT_RGB565);
    lv_display_set_flush_cb(display, flush);
    lv_display_set_buffers(display, lvBuffer, nullptr, lvBufferSize, LV_DISPLAY_RENDER_MODE_PARTIAL);

    //static auto* lvInput = lv_indev_create();
    //lv_indev_set_type(lvInput, LV_INDEV_TYPE_POINTER);
    //lv_indev_set_read_cb(lvInput, my_touch_read);

    pinMode(TFT_D0, OUTPUT);
    pinMode(TFT_D1, OUTPUT);
    pinMode(TFT_D2, OUTPUT);
    pinMode(TFT_D3, OUTPUT);
    pinMode(TFT_D4, OUTPUT);
    pinMode(TFT_D5, OUTPUT);
    pinMode(TFT_D6, OUTPUT);
    pinMode(TFT_D7, OUTPUT);
    pinMode(TFT_WR, OUTPUT);
    pinMode(TFT_FSYNC, OUTPUT);
    pinMode(TFT_RST, OUTPUT);
    pinMode(TFT_DC, OUTPUT);

    digitalWrite(TFT_RST, LOW); // Reset the display (important!)
    delay(100);
    digitalWrite(TFT_RST, HIGH);
    delay(100);

    lv_display_set_rotation(display, 90);  // Rotate the display 90 degrees

    lv_demo_widgets();


}

void loop() {
    lv_timer_handler(); // Process LVGL events and drawing
    delay(10);
}
//Flush and send8Bits are functions i found and tried to adapt for my use.
void flush(lv_display_t* disp, const lv_area_t* area, unsigned char* data) {
    // Implementation for ST7796U 8-bit parallel interface.
    uint32_t x = area->x1;
    uint32_t y = area->y1;
    uint32_t w = area->x2 - area->x1;
    uint32_t h = area->y2 - area->y1;

    // Iterate through the buffer and send data to the display.
    for (uint32_t i = 0; i < lvBufferSize / (screenWidth * screenHeight); ++i) {
        digitalWrite(TFT_DC, LOW); // Data/Command: Command
        digitalWrite(TFT_WR, LOW); // Write
        send8Bits(data + i * 2); // Assuming RGB565 (16 bits per pixel = 2 bytes)

        digitalWrite(TFT_WR, HIGH);
    }
}


void send8Bits(uint8_t* data) {
    // Send 8 bits in parallel.
    digitalWrite(TFT_FSYNC, LOW); // Start of frame sync
    digitalWrite(TFT_FSYNC, HIGH);

    digitalWrite(TFT_D0, (data[0] >> 7) & 0x01);
    digitalWrite(TFT_D1, (data[0] >> 6) & 0x01);
    digitalWrite(TFT_D2, (data[0] >> 5) & 0x01);
    digitalWrite(TFT_D3, (data[0] >> 4) & 0x01);
    digitalWrite(TFT_D4, (data[0] >> 3) & 0x01);
    digitalWrite(TFT_D5, (data[0] >> 2) & 0x01);
    digitalWrite(TFT_D6, (data[1] >> 7) & 0x01);
    digitalWrite(TFT_D7, (data[1] >> 6) & 0x01);
}

This gets a compiler error: 1:10: fatal error: ../../src/themes/lv_theme_private.h: No such file or directory even though the file is in the themes directory.

Tomorrow

It is late and I just wanted to post this and hope someone has ideas. I will be switching to the LGFX implementation from: here tomorrow but I do not expect it to fix my theme error.

lv_conf.h

/**
 * @file lv_conf.h
 * Configuration file for v9.3.0-dev
 */

 /*
  * Copy this file as `lv_conf.h`
  * 1. simply next to `lvgl` folder
  * 2. or to any other place and
  *    - define `LV_CONF_INCLUDE_SIMPLE`;
  *    - add the path as an include path.
  */

  /* clang-format off */
#if 1 /* Set this to "1" to enable content */

#ifndef LV_CONF_H
#define LV_CONF_H

/* If you need to include anything here, do it inside the `__ASSEMBLY__` guard */
#if  0 && defined(__ASSEMBLY__)
#include "my_include.h"
#endif

/*====================
   COLOR SETTINGS
 *====================*/

 /** Color depth: 1 (I1), 8 (L8), 16 (RGB565), 24 (RGB888), 32 (XRGB8888) */
#define LV_COLOR_DEPTH 16

/*=========================
   STDLIB WRAPPER SETTINGS
 *=========================*/

 /** Possible values
  * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
  * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
  * - LV_STDLIB_MICROPYTHON: MicroPython implementation
  * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
  * - LV_STDLIB_CUSTOM:      Implement the functions externally
  */
#define LV_USE_STDLIB_MALLOC    LV_STDLIB_BUILTIN

  /** Possible values
   * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
   * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
   * - LV_STDLIB_MICROPYTHON: MicroPython implementation
   * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
   * - LV_STDLIB_CUSTOM:      Implement the functions externally
   */
#define LV_USE_STDLIB_STRING    LV_STDLIB_BUILTIN

   /** Possible values
    * - LV_STDLIB_BUILTIN:     LVGL's built in implementation
    * - LV_STDLIB_CLIB:        Standard C functions, like malloc, strlen, etc
    * - LV_STDLIB_MICROPYTHON: MicroPython implementation
    * - LV_STDLIB_RTTHREAD:    RT-Thread implementation
    * - LV_STDLIB_CUSTOM:      Implement the functions externally
    */
#define LV_USE_STDLIB_SPRINTF   LV_STDLIB_BUILTIN

#define LV_STDINT_INCLUDE       <stdint.h>
#define LV_STDDEF_INCLUDE       <stddef.h>
#define LV_STDBOOL_INCLUDE      <stdbool.h>
#define LV_INTTYPES_INCLUDE     <inttypes.h>
#define LV_LIMITS_INCLUDE       <limits.h>
#define LV_STDARG_INCLUDE       <stdarg.h>

#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
    /** Size of memory available for `lv_malloc()` in bytes (>= 2kB) */
#define LV_MEM_SIZE (64 * 1024U)          /**< [bytes] */

/** Size of the memory expand for `lv_malloc()` in bytes */
#define LV_MEM_POOL_EXPAND_SIZE 0

/** Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too. */
#define LV_MEM_ADR 0     /**< 0: unused*/
/* Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc */
#if LV_MEM_ADR == 0
#undef LV_MEM_POOL_INCLUDE
#undef LV_MEM_POOL_ALLOC
#endif
#endif  /*LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN*/

/*====================
   HAL SETTINGS
 *====================*/

 /** Default display refresh, input device read and animation step period. */
#define LV_DEF_REFR_PERIOD  33      /**< [ms] */

/** Default Dots Per Inch. Used to initialize default sizes such as widgets sized, style paddings.
 * (Not so important, you can adjust it to modify default sizes and spaces.) */
#define LV_DPI_DEF 165              /**< [px/inch] */

 /*=================
  * OPERATING SYSTEM
  *=================*/
  /** Select operating system to use. Possible options:
   * - LV_OS_NONE
   * - LV_OS_PTHREAD
   * - LV_OS_FREERTOS
   * - LV_OS_CMSIS_RTOS2
   * - LV_OS_RTTHREAD
   * - LV_OS_WINDOWS
   * - LV_OS_MQX
   * - LV_OS_SDL2
   * - LV_OS_CUSTOM */
#define LV_USE_OS   LV_OS_NONE

#if LV_USE_OS == LV_OS_CUSTOM
#define LV_OS_CUSTOM_INCLUDE <stdint.h>
#endif
#if LV_USE_OS == LV_OS_FREERTOS
   /*
    * Unblocking an RTOS task with a direct notification is 45% faster and uses less RAM
    * than unblocking a task using an intermediary object such as a binary semaphore.
    * RTOS task notifications can only be used when there is only one task that can be the recipient of the event.
    */
#define LV_USE_FREERTOS_TASK_NOTIFY 1
#endif

    /*========================
     * RENDERING CONFIGURATION
     *========================*/

     /** Align stride of all layers and images to this bytes */
#define LV_DRAW_BUF_STRIDE_ALIGN                1

/** Align start address of draw_buf addresses to this bytes*/
#define LV_DRAW_BUF_ALIGN                       4

/** Using matrix for transformations.
 * Requirements:
 * - `LV_USE_MATRIX = 1`.
 * - Rendering engine needs to support 3x3 matrix transformations. */
#define LV_DRAW_TRANSFORM_USE_MATRIX            0

 /* If a widget has `style_opa < 255` (not `bg_opa`, `text_opa` etc) or not NORMAL blend mode
  * it is buffered into a "simple" layer before rendering. The widget can be buffered in smaller chunks.
  * "Transformed layers" (if `transform_angle/zoom` are set) use larger buffers
  * and can't be drawn in chunks. */

  /** The target buffer size for simple layer chunks. */
#define LV_DRAW_LAYER_SIMPLE_BUF_SIZE    (24 * 1024)    /**< [bytes]*/

/* Limit the max allocated memory for simple and transformed layers.
 * It should be at least `LV_DRAW_LAYER_SIMPLE_BUF_SIZE` sized but if transformed layers are also used
 * it should be enough to store the largest widget too (width x height x 4 area).
 * Set it to 0 to have no limit. */
#define LV_DRAW_LAYER_MAX_MEMORY 0  /**< No limit by default [bytes]*/

 /** Stack size of drawing thread.
  * NOTE: If FreeType or ThorVG is enabled, it is recommended to set it to 32KB or more.
  */
#define LV_DRAW_THREAD_STACK_SIZE    (8 * 1024)         /**< [bytes]*/

#define LV_USE_DRAW_SW 1
#if LV_USE_DRAW_SW == 1
  /*
   * Selectively disable color format support in order to reduce code size.
   * NOTE: some features use certain color formats internally, e.g.
   * - gradients use RGB888
   * - bitmaps with transparency may use ARGB8888
   */
#define LV_DRAW_SW_SUPPORT_RGB565       1
#define LV_DRAW_SW_SUPPORT_RGB565A8     1
#define LV_DRAW_SW_SUPPORT_RGB888       1
#define LV_DRAW_SW_SUPPORT_XRGB8888     1
#define LV_DRAW_SW_SUPPORT_ARGB8888     1
#define LV_DRAW_SW_SUPPORT_L8           1
#define LV_DRAW_SW_SUPPORT_AL88         1
#define LV_DRAW_SW_SUPPORT_A8           1
#define LV_DRAW_SW_SUPPORT_I1           1

   /* The threshold of the luminance to consider a pixel as
    * active in indexed color format */
#define LV_DRAW_SW_I1_LUM_THRESHOLD 127

    /** Set number of draw units.
     *  - > 1 requires operating system to be enabled in `LV_USE_OS`.
     *  - > 1 means multiple threads will render the screen in parallel. */
#define LV_DRAW_SW_DRAW_UNIT_CNT    1

     /** Use Arm-2D to accelerate software (sw) rendering. */
#define LV_USE_DRAW_ARM2D_SYNC      0

/** Enable native helium assembly to be compiled. */
#define LV_USE_NATIVE_HELIUM_ASM    0

/**
 * - 0: Use a simple renderer capable of drawing only simple rectangles with gradient, images, text, and straight lines only.
 * - 1: Use a complex renderer capable of drawing rounded corners, shadow, skew lines, and arcs too. */
#define LV_DRAW_SW_COMPLEX          1

#if LV_DRAW_SW_COMPLEX == 1
 /** Allow buffering some shadow calculation.
  *  LV_DRAW_SW_SHADOW_CACHE_SIZE is the maximum shadow size to buffer, where shadow size is
  *  `shadow_width + radius`.  Caching has LV_DRAW_SW_SHADOW_CACHE_SIZE^2 RAM cost. */
#define LV_DRAW_SW_SHADOW_CACHE_SIZE 0

  /** Set number of maximally-cached circle data.
   *  The circumference of 1/4 circle are saved for anti-aliasing.
   *  `radius * 4` bytes are used per circle (the most often used radiuses are saved).
   *  - 0: disables caching */
#define LV_DRAW_SW_CIRCLE_CACHE_SIZE 4
#endif

#define  LV_USE_DRAW_SW_ASM     LV_DRAW_SW_ASM_NONE

#if LV_USE_DRAW_SW_ASM == LV_DRAW_SW_ASM_CUSTOM
#define  LV_DRAW_SW_ASM_CUSTOM_INCLUDE ""
#endif

   /** Enable drawing complex gradients in software: linear at an angle, radial or conical */
#define LV_USE_DRAW_SW_COMPLEX_GRADIENTS    0

#endif

/*Use TSi's aka (Think Silicon) NemaGFX */
#define LV_USE_NEMA_GFX 0

#if LV_USE_NEMA_GFX
    /** Select which NemaGFX HAL to use. Possible options:
     * - LV_NEMA_HAL_CUSTOM
     * - LV_NEMA_HAL_STM32 */
#define LV_USE_NEMA_HAL LV_NEMA_HAL_CUSTOM
#if LV_USE_NEMA_HAL == LV_NEMA_HAL_STM32
#define LV_NEMA_STM32_HAL_INCLUDE <stm32u5xx_hal.h>
#endif

     /*Enable Vector Graphics Operations. Available only if NemaVG library is present*/
#define LV_USE_NEMA_VG 0
#if LV_USE_NEMA_VG
    /*Define application's resolution used for VG related buffer allocation */
#define LV_NEMA_GFX_MAX_RESX 800
#define LV_NEMA_GFX_MAX_RESY 600
#endif
#endif

/** Use NXP's VG-Lite GPU on iMX RTxxx platforms. */
#define LV_USE_DRAW_VGLITE 0

#if LV_USE_DRAW_VGLITE
    /** Enable blit quality degradation workaround recommended for screen's dimension > 352 pixels. */
#define LV_USE_VGLITE_BLIT_SPLIT 0

#if LV_USE_OS
    /** Use additional draw thread for VG-Lite processing. */
#define LV_USE_VGLITE_DRAW_THREAD 1

#if LV_USE_VGLITE_DRAW_THREAD
    /** Enable VGLite draw async. Queue multiple tasks and flash them once to the GPU. */
#define LV_USE_VGLITE_DRAW_ASYNC 1
#endif
#endif

/** Enable VGLite asserts. */
#define LV_USE_VGLITE_ASSERT 0
#endif

/** Use NXP's PXP on iMX RTxxx platforms. */
#define LV_USE_PXP 0

#if LV_USE_PXP
    /** Use PXP for drawing.*/
#define LV_USE_DRAW_PXP 1

/** Use PXP to rotate display.*/
#define LV_USE_ROTATE_PXP 0

#if LV_USE_DRAW_PXP && LV_USE_OS
    /** Use additional draw thread for PXP processing.*/
#define LV_USE_PXP_DRAW_THREAD 1
#endif

/** Enable PXP asserts. */
#define LV_USE_PXP_ASSERT 0
#endif

/** Use NXP's G2D on MPU platforms. */
#define LV_USE_DRAW_G2D 0

#if LV_USE_DRAW_G2D
    /** Maximum number of buffers that can be stored for G2D draw unit.
     *  Includes the frame buffers and assets. */
#define LV_G2D_HASH_TABLE_SIZE 50

#if LV_USE_OS
     /** Use additional draw thread for G2D processing.*/
#define LV_USE_G2D_DRAW_THREAD 1
#endif

/** Enable G2D asserts. */
#define LV_USE_G2D_ASSERT 0
#endif

/** Use Renesas Dave2D on RA  platforms. */
#define LV_USE_DRAW_DAVE2D 0

/** Draw using cached SDL textures*/
#define LV_USE_DRAW_SDL 0

/** Use VG-Lite GPU. */
#define LV_USE_DRAW_VG_LITE 0

#if LV_USE_DRAW_VG_LITE
    /** Enable VG-Lite custom external 'gpu_init()' function */
#define LV_VG_LITE_USE_GPU_INIT 0

/** Enable VG-Lite assert. */
#define LV_VG_LITE_USE_ASSERT 0

/** VG-Lite flush commit trigger threshold. GPU will try to batch these many draw tasks. */
#define LV_VG_LITE_FLUSH_MAX_COUNT 8

/** Enable border to simulate shadow.
 *  NOTE: which usually improves performance,
 *  but does not guarantee the same rendering quality as the software. */
#define LV_VG_LITE_USE_BOX_SHADOW 0

 /** VG-Lite gradient maximum cache number.
  *  @note  The memory usage of a single gradient image is 4K bytes. */
#define LV_VG_LITE_GRAD_CACHE_CNT 32

  /** VG-Lite stroke maximum cache number. */
#define LV_VG_LITE_STROKE_CACHE_CNT 32
#endif

/** Accelerate blends, fills, etc. with STM32 DMA2D */
#define LV_USE_DRAW_DMA2D 0

#if LV_USE_DRAW_DMA2D
#define LV_DRAW_DMA2D_HAL_INCLUDE "stm32h7xx_hal.h"

/* if enabled, the user is required to call `lv_draw_dma2d_transfer_complete_interrupt_handler`
 * upon receiving the DMA2D global interrupt
 */
#define LV_USE_DRAW_DMA2D_INTERRUPT 0
#endif

 /** Draw using cached OpenGLES textures */
#define LV_USE_DRAW_OPENGLES 0

/*=======================
 * FEATURE CONFIGURATION
 *=======================*/

 /*-------------
  * Logging
  *-----------*/

  /** Enable log module */
#define LV_USE_LOG 0
#if LV_USE_LOG
    /** Set value to one of the following levels of logging detail:
     *  - LV_LOG_LEVEL_TRACE    Log detailed information.
     *  - LV_LOG_LEVEL_INFO     Log important events.
     *  - LV_LOG_LEVEL_WARN     Log if something unwanted happened but didn't cause a problem.
     *  - LV_LOG_LEVEL_ERROR    Log only critical issues, when system may fail.
     *  - LV_LOG_LEVEL_USER     Log only custom log messages added by the user.
     *  - LV_LOG_LEVEL_NONE     Do not log anything. */
#define LV_LOG_LEVEL LV_LOG_LEVEL_WARN

     /** - 1: Print log with 'printf';
      *  - 0: User needs to register a callback with `lv_log_register_print_cb()`. */
#define LV_LOG_PRINTF 0

      /** Set callback to print logs.
       *  E.g `my_print`. The prototype should be `void my_print(lv_log_level_t level, const char * buf)`.
       *  Can be overwritten by `lv_log_register_print_cb`. */
       //#define LV_LOG_PRINT_CB

       /** - 1: Enable printing timestamp;
        *  - 0: Disable printing timestamp. */
#define LV_LOG_USE_TIMESTAMP 1

        /** - 1: Print file and line number of the log;
         *  - 0: Do not print file and line number of the log. */
#define LV_LOG_USE_FILE_LINE 1

         /* Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs. */
#define LV_LOG_TRACE_MEM        1   /**< Enable/disable trace logs in memory operations. */
#define LV_LOG_TRACE_TIMER      1   /**< Enable/disable trace logs in timer operations. */
#define LV_LOG_TRACE_INDEV      1   /**< Enable/disable trace logs in input device operations. */
#define LV_LOG_TRACE_DISP_REFR  1   /**< Enable/disable trace logs in display re-draw operations. */
#define LV_LOG_TRACE_EVENT      1   /**< Enable/disable trace logs in event dispatch logic. */
#define LV_LOG_TRACE_OBJ_CREATE 1   /**< Enable/disable trace logs in object creation (core `obj` creation plus every widget). */
#define LV_LOG_TRACE_LAYOUT     1   /**< Enable/disable trace logs in flex- and grid-layout operations. */
#define LV_LOG_TRACE_ANIM       1   /**< Enable/disable trace logs in animation logic. */
#define LV_LOG_TRACE_CACHE      1   /**< Enable/disable trace logs in cache operations. */
#endif  /*LV_USE_LOG*/

/*-------------
 * Asserts
 *-----------*/

 /* Enable assertion failures if an operation fails or invalid data is found.
  * If LV_USE_LOG is enabled, an error message will be printed on failure. */
#define LV_USE_ASSERT_NULL          1   /**< Check if the parameter is NULL. (Very fast, recommended) */
#define LV_USE_ASSERT_MALLOC        1   /**< Checks is the memory is successfully allocated or no. (Very fast, recommended) */
#define LV_USE_ASSERT_STYLE         0   /**< Check if the styles are properly initialized. (Very fast, recommended) */
#define LV_USE_ASSERT_MEM_INTEGRITY 0   /**< Check the integrity of `lv_mem` after critical operations. (Slow) */
#define LV_USE_ASSERT_OBJ           0   /**< Check the object's type and existence (e.g. not deleted). (Slow) */

  /** Add a custom handler when assert happens e.g. to restart MCU. */
#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
#define LV_ASSERT_HANDLER while(1);     /**< Halt by default */

/*-------------
 * Debug
 *-----------*/

 /** 1: Draw random colored rectangles over the redrawn areas. */
#define LV_USE_REFR_DEBUG 0

/** 1: Draw a red overlay for ARGB layers and a green overlay for RGB layers*/
#define LV_USE_LAYER_DEBUG 0

/** 1: Adds the following behaviors for debugging:
 *  - Draw overlays with different colors for each draw_unit's tasks.
 *  - Draw index number of draw unit on white background.
 *  - For layers, draws index number of draw unit on black background. */
#define LV_USE_PARALLEL_DRAW_DEBUG 0

 /*-------------
  * Others
  *-----------*/

#define LV_ENABLE_GLOBAL_CUSTOM 0
#if LV_ENABLE_GLOBAL_CUSTOM
  /** Header to include for custom 'lv_global' function" */
#define LV_GLOBAL_CUSTOM_INCLUDE <stdint.h>
#endif

/** Default cache size in bytes.
 *  Used by image decoders such as `lv_lodepng` to keep the decoded image in memory.
 *  If size is not set to 0, the decoder will fail to decode when the cache is full.
 *  If size is 0, the cache function is not enabled and the decoded memory will be
 *  released immediately after use. */
#define LV_CACHE_DEF_SIZE       0

 /** Default number of image header cache entries. The cache is used to store the headers of images
  *  The main logic is like `LV_CACHE_DEF_SIZE` but for image headers. */
#define LV_IMAGE_HEADER_CACHE_DEF_CNT 0

  /** Number of stops allowed per gradient. Increase this to allow more stops.
   *  This adds (sizeof(lv_color_t) + 1) bytes per additional stop. */
#define LV_GRADIENT_MAX_STOPS   2

   /** Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
    *  - 0:   round down,
    *  - 64:  round up from x.75,
    *  - 128: round up from half,
    *  - 192: round up from x.25,
    *  - 254: round up */
#define LV_COLOR_MIX_ROUND_OFS  0

    /** Add 2 x 32-bit variables to each `lv_obj_t` to speed up getting style properties */
#define LV_OBJ_STYLE_CACHE      0

/** Add `id` field to `lv_obj_t` */
#define LV_USE_OBJ_ID           0

/**  Enable support widget names*/
#define LV_USE_OBJ_NAME         0

/** Automatically assign an ID when obj is created */
#define LV_OBJ_ID_AUTO_ASSIGN   LV_USE_OBJ_ID

/** Use builtin obj ID handler functions:
* - lv_obj_assign_id:       Called when a widget is created. Use a separate counter for each widget class as an ID.
* - lv_obj_id_compare:      Compare the ID to decide if it matches with a requested value.
* - lv_obj_stringify_id:    Return string-ified identifier, e.g. "button3".
* - lv_obj_free_id:         Does nothing, as there is no memory allocation for the ID.
* When disabled these functions needs to be implemented by the user.*/
#define LV_USE_OBJ_ID_BUILTIN   1

/** Use obj property set/get API. */
#define LV_USE_OBJ_PROPERTY 0

/** Enable property name support. */
#define LV_USE_OBJ_PROPERTY_NAME 1

/* Use VG-Lite Simulator.
 * - Requires: LV_USE_THORVG_INTERNAL or LV_USE_THORVG_EXTERNAL */
#define LV_USE_VG_LITE_THORVG  0

#if LV_USE_VG_LITE_THORVG
 /** Enable LVGL's blend mode support */
#define LV_VG_LITE_THORVG_LVGL_BLEND_SUPPORT 0

/** Enable YUV color format support */
#define LV_VG_LITE_THORVG_YUV_SUPPORT 0

/** Enable Linear gradient extension support */
#define LV_VG_LITE_THORVG_LINEAR_GRADIENT_EXT_SUPPORT 0

/** Enable alignment on 16 pixels */
#define LV_VG_LITE_THORVG_16PIXELS_ALIGN 1

/** Buffer address alignment */
#define LV_VG_LITE_THORVG_BUF_ADDR_ALIGN 64

/** Enable multi-thread render */
#define LV_VG_LITE_THORVG_THREAD_RENDER 0
#endif

/* Enable the multi-touch gesture recognition feature */
/* Gesture recognition requires the use of floats */
#define LV_USE_GESTURE_RECOGNITION 0

/*=====================
 *  COMPILER SETTINGS
 *====================*/

 /** For big endian systems set to 1 */
#define LV_BIG_ENDIAN_SYSTEM 0

/** Define a custom attribute for `lv_tick_inc` function */
#define LV_ATTRIBUTE_TICK_INC

/** Define a custom attribute for `lv_timer_handler` function */
#define LV_ATTRIBUTE_TIMER_HANDLER

/** Define a custom attribute for `lv_display_flush_ready` function */
#define LV_ATTRIBUTE_FLUSH_READY

/** Align VG_LITE buffers on this number of bytes.
 *  @note  vglite_src_buf_aligned() uses this value to validate alignment of passed buffer pointers. */
#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1

 /** Will be added where memory needs to be aligned (with -Os data might not be aligned to boundary by default).
  *  E.g. __attribute__((aligned(4)))*/
#define LV_ATTRIBUTE_MEM_ALIGN

  /** Attribute to mark large constant arrays, for example for font bitmaps */
#define LV_ATTRIBUTE_LARGE_CONST

/** Compiler prefix for a large array declaration in RAM */
#define LV_ATTRIBUTE_LARGE_RAM_ARRAY

/** Place performance critical functions into a faster memory (e.g RAM) */
#define LV_ATTRIBUTE_FAST_MEM

/** Export integer constant to binding. This macro is used with constants in the form of LV_<CONST> that
 *  should also appear on LVGL binding API such as MicroPython. */
#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning  /**< The default value just prevents GCC warning */

 /** Prefix all global extern data with this */
#define LV_ATTRIBUTE_EXTERN_DATA

/** Use `float` as `lv_value_precise_t` */
#define LV_USE_FLOAT            0

/** Enable matrix support
 *  - Requires `LV_USE_FLOAT = 1` */
#define LV_USE_MATRIX           0

 /** Include `lvgl_private.h` in `lvgl.h` to access internal data and functions by default */
#define LV_USE_PRIVATE_API      0

/*==================
 *   FONT USAGE
 *===================*/

 /* Montserrat fonts with ASCII range and some symbols using bpp = 4
  * https://fonts.google.com/specimen/Montserrat */
#define LV_FONT_MONTSERRAT_8  0
#define LV_FONT_MONTSERRAT_10 0
#define LV_FONT_MONTSERRAT_12 0
#define LV_FONT_MONTSERRAT_14 1
#define LV_FONT_MONTSERRAT_16 0
#define LV_FONT_MONTSERRAT_18 0
#define LV_FONT_MONTSERRAT_20 0
#define LV_FONT_MONTSERRAT_22 0
#define LV_FONT_MONTSERRAT_24 0
#define LV_FONT_MONTSERRAT_26 0
#define LV_FONT_MONTSERRAT_28 0
#define LV_FONT_MONTSERRAT_30 0
#define LV_FONT_MONTSERRAT_32 0
#define LV_FONT_MONTSERRAT_34 0
#define LV_FONT_MONTSERRAT_36 0
#define LV_FONT_MONTSERRAT_38 0
#define LV_FONT_MONTSERRAT_40 0
#define LV_FONT_MONTSERRAT_42 0
#define LV_FONT_MONTSERRAT_44 0
#define LV_FONT_MONTSERRAT_46 0
#define LV_FONT_MONTSERRAT_48 0

  /* Demonstrate special features */
#define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /**< bpp = 3 */
#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /**< Hebrew, Arabic, Persian letters and all their forms */
#define LV_FONT_SIMSUN_14_CJK            0  /**< 1000 most common CJK radicals */
#define LV_FONT_SIMSUN_16_CJK            0  /**< 1000 most common CJK radicals */

/** Pixel perfect monospaced fonts */
#define LV_FONT_UNSCII_8  0
#define LV_FONT_UNSCII_16 0

/** Optionally declare custom fonts here.
 *
 *  You can use any of these fonts as the default font too and they will be available
 *  globally.  Example:
 *
 *  @code
 *  #define LV_FONT_CUSTOM_DECLARE   LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)
 *  @endcode
 */
#define LV_FONT_CUSTOM_DECLARE

 /** Always set a default font */
#define LV_FONT_DEFAULT &lv_font_montserrat_14

/** Enable handling large font and/or fonts with a lot of characters.
 *  The limit depends on the font size, font face and bpp.
 *  A compiler error will be triggered if a font needs it. */
#define LV_FONT_FMT_TXT_LARGE 0

 /** Enables/disables support for compressed fonts. */
#define LV_USE_FONT_COMPRESSED 0

/** Enable drawing placeholders when glyph dsc is not found. */
#define LV_USE_FONT_PLACEHOLDER 1

Switching to LovyanGFX gets me to the same point, still failing on the theme file:

1:10: fatal error: ../../src/themes/lv_theme_private.h: No such file or directory

Just as a follow up, I have followed the steps here

specifically the section:

Note that, there is no dedicated INO file for every example. Instead, you can load an example by calling an `lv_example_...` function. For example `lv_example_btn_1()`.

important:

Due to some the limitations of Arduino's build system you need to copy `lvgl/examples` to `lvgl/src/examples`. Similarly for the demos `lvgl/demos` to `lvgl/src/demos`.

I also found someone else with a similar issue here but can’t seem to figure out what their actual solution was since it seems to have been to just do the above

Still stuck unable to compile with:

The lvgl library encountered an unknown path resolve error.Z*: 1:10: fatal error: ../../src/themes/lv_theme_private.h: No such file or directory
   #include "../../src/themes/lv_theme_private.h"

I’ve tried redownloading everything and writing everything from scratch again, config file, everything… still this error not even specifying a file causing the issue.

If anyone else stumbles upon this issue, if you download the newest version from github rather than use the Arduino library installer, put it in a subfolder and include the lvgl.h file while following the other instructions and setup your own demo instead of using theirs things will compile.

Still no luck getting the default demo widget to work, but I got a graph to display so that’s something