I'm getting a RAM Overflow with the "Hello Arduino" example - BluePill with Arduino-Style Code


I’m trying to get LVGL to compile, but keep getting a RAM overflow error. I disabled all the fancy features (anti-aliasing, all the widgets except the label, and most everything else), tried reducing the frame buffer, and everything else I could think of, but it still won’t go! :confused: I’m using TFT_eSPI as the driver library, and I have its fancy features disabled as well. The TFT_eSPI demo for my 480x320 screen works without a hitch.

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

I’m using a BluePill (STM32F103C8T6) with an ILI9486 display from “Kuman” on Amazon. I know it’s not a high-performance board, but all I want to do is show a simple tank level indicator, and I’ve seen some pretty impressive stuff done with a BluePill and LVGL.

I’m using PlatformIO in VSCode with the Arduino method of programming the STM32.

What do you want to achieve?

Successfully compile the example code on Github.

What have you tried so far?

I disabled almost everything in LVGL and played with the size of the frame buffer.

Code to reproduce

Here’s my current stripped-down example code:

#include <Arduino.h>
#include <lvgl.h>
#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI(); /* TFT instance */

/*Change to your screen resolution*/
static const uint32_t screenWidth  = 480;
static const uint32_t screenHeight = 320;

static lv_disp_draw_buf_t draw_buf;
static lv_color_t buf[screenWidth * 10];

/* Display flushing */
void my_disp_flush( lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p )
   uint32_t w = ( area->x2 - area->x1 + 1 );
   uint32_t h = ( area->y2 - area->y1 + 1 );

   tft.setAddrWindow( area->x1, area->y1, w, h );
   tft.pushColors( ( uint16_t * )&color_p->full, w * h, true );

   lv_disp_flush_ready( disp );

void setup()


   tft.begin();          /* TFT init */
   tft.setRotation( 3 ); /* Landscape orientation, flipped */

   lv_disp_draw_buf_init( &draw_buf, buf, NULL, screenWidth * 10 );

   /*Initialize the display*/
   static lv_disp_drv_t disp_drv;
   lv_disp_drv_init( &disp_drv );
   /*Change the following line to your display resolution*/
   disp_drv.hor_res = screenWidth;
   disp_drv.ver_res = screenHeight;
   disp_drv.flush_cb = my_disp_flush;
   disp_drv.draw_buf = &draw_buf;
   lv_disp_drv_register( &disp_drv );

   /* Create simple label */
   lv_obj_t *label = lv_label_create( lv_scr_act() );
   lv_label_set_text( label, "Hello Arduino! (V8.0.X)" );
   lv_obj_align( label, LV_ALIGN_CENTER, 0, 0 );


void loop()
   lv_timer_handler(); /* let the GUI do its work */
   delay( 5 );

My lv_conf file:

 * @file lv_conf.h
 * Configuration file for v8.0.0-dev

 * COPY THIS FILE AS `lv_conf.h` NEXT TO the `lvgl` FOLDER

#if 1 /*Set it to "1" to enable content*/

#ifndef LV_CONF_H
#define LV_CONF_H
/* clang-format off */

#include <stdint.h>


/* Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888) */
#define LV_COLOR_DEPTH     16

/* Swap the 2 bytes of RGB565 color. Useful if the display has a 8 bit interface (e.g. SPI)*/
#define LV_COLOR_16_SWAP   0

/* Enable more complex drawing routines to manage screens transparency.
 * Can be used if the UI is above an other layer, e.g. an OSD menu or video player.
 * Requires `LV_COLOR_DEPTH = 32` colors and the screen's `bg_opa` should be set to non LV_OPA_COVER value */

/*Images pixels with this color will not be drawn if they are  chroma keyed)*/
#define LV_COLOR_CHROMA_KEY    lv_color_hex(0x00ff00)         /*pure green*/


/* 1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()` */
#define LV_MEM_CUSTOM      0
#if LV_MEM_CUSTOM == 0
/* Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/
#  define LV_MEM_SIZE    (32U * 1024U)          /* [bytes] */

/* 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*/
#else       /*LV_MEM_CUSTOM*/
#  define LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
#  define LV_MEM_CUSTOM_ALLOC     malloc
#  define LV_MEM_CUSTOM_FREE      free
#  define LV_MEM_CUSTOM_REALLOC   realloc
#endif     /*LV_MEM_CUSTOM*/

/* Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster). */


/* Default display refresh period. LVG will redraw changed ares with this period time */
#define LV_DISP_DEF_REFR_PERIOD     30      /*[ms]*/

/* Input device read period in milliseconds */
#define LV_INDEV_DEF_READ_PERIOD    30      /*[ms]*/

/* Use a custom tick source that tells the elapsed time in milliseconds.
 * It removes the need to manually update the tick with `lv_tick_inc()`) */
#define LV_TICK_CUSTOM     1
#define LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
#endif   /*LV_TICK_CUSTOM*/

/* Default Dot 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                  130     /*[px/inch]*/

#define LV_HOR_RES_MAX     480
#define LV_VER_RES_MAX     320


 * Drawing

/* Enable complex draw engine.
 * Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks  */

/* Allow buffering some shadow calculation.
 * LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius`
 * Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
#endif /*LV_DRAW_COMPLEX*/

/* Default image cache size. Image caching keeps the images opened.
 * If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added)
 * With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
 * However the opened images might consume additional RAM.
 * 0: to disable caching */
#define LV_IMG_CACHE_DEF_SIZE       0

/* Maximum buffer size to allocate for rotation. Only used if software rotation is enabled in the display driver. */
#define LV_DISP_ROT_MAX_BUF         (10*1024)
 * GPU

/*Use STM32's DMA2D (aka Chrom Art) GPU*/
#define LV_USE_GPU_STM32_DMA2D  0
/*Must be defined to include path of CMSIS header of target processor
e.g. "stm32f769xx.h" or "stm32f429xx.h" */

/* Use NXP's PXP GPU iMX RTxxx platforms */
#define LV_USE_GPU_NXP_PXP      0
/*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
 *   and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol FSL_RTOS_FREE_RTOS
 *   has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected.
 *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init()
 * */

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

 * Logging

/*Enable the log module*/
#define LV_USE_LOG      0

/* How important log should be added:
 * LV_LOG_LEVEL_TRACE       A lot of logs to give 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       Only critical issue, when the system may fail
 * LV_LOG_LEVEL_USER        Only logs added by the user
 * LV_LOG_LEVEL_NONE        Do not log anything */

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

/*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs */
#  define LV_LOG_TRACE_MEM            1
#  define LV_LOG_TRACE_TIMER          1
#  define LV_LOG_TRACE_INDEV          1
#  define LV_LOG_TRACE_DISP_REFR      1
#  define LV_LOG_TRACE_EVENT          1
#  define LV_LOG_TRACE_SIGNAL         1
#  define LV_LOG_TRACE_OBJ_CREATE     1
#  define LV_LOG_TRACE_LAYOUT         1
#  define LV_LOG_TRACE_ANIM           1

#endif  /*LV_USE_LOG*/

 * Asserts

/* Enable asserts if an operation is failed or an invalid data is found.
 * If LV_USE_LOG is enabled an error message will be printed on failure*/
#define LV_USE_ASSERT_NULL          0   /*Check if the parameter is NULL. (Very fast, recommended) */
#define LV_USE_ASSERT_MALLOC        0   /*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 the MCU*/
#define LV_ASSERT_HANDLER_INCLUDE   <stdint.h>
#define LV_ASSERT_HANDLER   while(1);   /*Halt by default*/

 * Others

/*1: Show CPU usage and FPS count in the right bottom corner*/
#define LV_USE_PERF_MONITOR     0

/*1: Show the used memory and the memory fragmentation  in the left bottom corner
 * Requires LV_MEM_CUSTOM = 0*/
#define LV_USE_MEM_MONITOR      0

/*Change the built in (v)snprintf functions*/
#  define LV_SPRINTF_INCLUDE <stdio.h>
#  define lv_snprintf     snprintf
#  define lv_vsnprintf    vsnprintf

#define LV_USE_USER_DATA      0
typedef void * lv_user_data_t;

/* Garbage Collector settings
 * Used if lvgl is binded to higher level language and the memory is managed by that language */
#define LV_ENABLE_GC 0
#if LV_ENABLE_GC != 0
#  define LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
#endif /* LV_ENABLE_GC */


/* For big endian systems set to 1 */

/* Define a custom attribute to `lv_tick_inc` function */

/* Define a custom attribute to `lv_timer_handler` function */

/* Define a custom attribute to `lv_disp_flush_ready` function */

/* Required alignment size for buffers */

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

/* Attribute to mark large constant arrays for example font's bitmaps */

/* Complier prefix for a big array declaration in RAM*/

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

/* Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible */

/* 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*/

/*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/


/* 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_12_SUBPX      0
#define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, Perisan letters and all their forms*/
#define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/

/*Pixel perfect monospace fonts
 * http://pelulamu.net/unscii/ */
#define LV_FONT_UNSCII_8        0
#define LV_FONT_UNSCII_16       0

/* Optionally declare custom fonts here.
 * You can use these fonts as default font too and they will be available globally.
 * E.g. #define LV_FONT_CUSTOM_DECLARE   LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2) */

/*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.
 * Compiler error will be triggered if a font needs it.*/

/* Enables/disables support for compressed fonts. */

/* Enable subpixel rendering */
#define LV_USE_FONT_SUBPX       0
/* Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/
#define LV_FONT_SUBPX_BGR       0  /*0: RGB; 1:BGR order*/


/* Select a character encoding for strings.
 * Your IDE or editor should have the same character encoding
 * */

 /*Can break (wrap) texts on these chars*/
#define LV_TXT_BREAK_CHARS                  " ,.;:-_"

/* If a word is at least this long, will break wherever "prettiest"
 * To disable, set to a value <= 0 */
#define LV_TXT_LINE_BREAK_LONG_LEN          0

/* Minimum number of characters in a long word to put on a line before a break.
 * Depends on LV_TXT_LINE_BREAK_LONG_LEN. */

/* Minimum number of characters in a long word to put on a line after a break.
 * Depends on LV_TXT_LINE_BREAK_LONG_LEN. */

/* The control character to use for signalling text recoloring. */
#define LV_TXT_COLOR_CMD "#"

/* Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts.
 * The direction will be processed according to the Unicode Bidirectioanl Algorithm:
 * https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
#define LV_USE_BIDI         0
/* Set the default direction. Supported values:
 * `LV_BIDI_DIR_LTR` Left-to-Right
 * `LV_BIDI_DIR_RTL` Right-to-Left
 * `LV_BIDI_DIR_AUTO` detect texts base direction */

/* Enable Arabic/Persian processing
 * In these languages characters should be replaced with an other form based on their position in the text */


/* Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html */

#define LV_USE_ARC          0

#define LV_USE_ANIMIMG	    0

#define LV_USE_BAR          0

#define LV_USE_BTN          0

#define LV_USE_BTNMATRIX    0

#define LV_USE_CANVAS       0

#define LV_USE_CHECKBOX     0

#define LV_USE_CHART        0

#define LV_USE_DROPDOWN     0   /*Requires: lv_label*/

#define LV_USE_IMG          0   /*Requires: lv_label*/

#define LV_USE_LABEL        1
#  define LV_LABEL_TEXT_SEL         0   /*Enable selecting text of the label */
#  define LV_LABEL_LONG_TXT_HINT    0   /*Store some extra info in labels to speed up drawing of very long texts*/

#define LV_USE_LINE         0

#define LV_USE_METER        0

#define LV_USE_ROLLER       0   /*Requires: lv_label*/
#  define LV_ROLLER_INF_PAGES       7   /*Number of extra "pages" when the roller is infinite*/

#define LV_USE_SLIDER       0   /*Requires: lv_bar*/

#define LV_USE_SWITCH    0

#define LV_USE_TEXTAREA   0     /*Requires: lv_label*/
#  define LV_TEXTAREA_DEF_PWD_SHOW_TIME     1500    /*ms*/

#define LV_USE_TABLE  0


 * Widgets
#define LV_USE_CALENDAR     0
#  define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
# else
#  define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
# endif

# define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
#endif  /*LV_USE_CALENDAR*/


#define LV_USE_IMGBTN       0

#define LV_USE_KEYBOARD     0

#define LV_USE_LED          0

#define LV_USE_LIST         0

#define LV_USE_MSGBOX       0

#define LV_USE_SPINBOX      0

#define LV_USE_SPINNER      0

#define LV_USE_TABVIEW      0

#define LV_USE_TILEVIEW     0

#define LV_USE_WIN          0

 * Themes
/* A simple, impressive and very complete theme */

/* 1: Light mode; 0: Dark mode*/

/* 1: Enable grow on press*/
# define LV_THEME_DEFAULT_GROW        		0

/*Default transition time in [ms]*/

 * Layouts
#define LV_USE_FLEX     0
#define LV_USE_GRID     0


/*Enable the examples to be built with the library*/

/*--END OF LV_CONF_H--*/

#endif /*LV_CONF_H*/

#endif /*End of "Content enable"*/

And finally, the exact compiler output:

Linking .pio\build\genericSTM32F103C8\firmware.elf
c:/users/jadon/.platformio/packages/toolchain-gccarmnoneeabi/bin/../lib/gcc/arm-none-eabi/9.2.1/../../../../arm-none-eabi/bin/ld.exe: .pio/build/genericSTM32F103C8/firmware.elf section `.bss' will not fit in region `RAM'
c:/users/jadon/.platformio/packages/toolchain-gccarmnoneeabi/bin/../lib/gcc/arm-none-eabi/9.2.1/../../../../arm-none-eabi/bin/ld.exe: region `RAM' overflowed by 25392 bytes

I’m really excited about the power of LVGL, but I’m really stuck right now. I could just buy a better processor, but I think I should be able to do a very basic “Hello Arduino” screen with 128k Flash and 20k RAM. Thanks a lot for your help – I really do appreciate it!


How about changing the screen size to 320 x 240. Just to see if it compiles.

I hope you can get it to work. I would be nice to be able to use the blue pill board. I had thought about it but decided the black pill was more appropriate.

I also tried to run LVGL on a STM32F103 but it didn’t have enough resources. I recomand one of the blue-pills with STM32F401CE or STM32F411CE. (Make sure to get “CE”, not 'CC").

There black-pills come with several pinouts. The one lead by WeAct seems to be the leading one, https://github.com/WeActTC/MiniSTM32F4x1

Edit: Since then I switched from black-pills to the green-pill (Raspberry Pico). Getting excellent performance, good price, and predictable quality. It has sufficient RAM to hold the entire 320x480 in RAM (using 8 bits pixels) and in 16bit parallel mode can write to the ILI9488 at > 10M pixels/sec (which is equivalent to > 160M pixels/sec in SPI equivalent)

I already tried that (sorry, I forgot to write it down), but I still overflow by about 22,000 bytes.

Did you get the BluePill to run LVGL at all? Other people have made some neat things with it online, but I’m struggling. Thanks for the tip on the Pico! I hadn’t thought of that. Amazingly, they’re actually cheaper than most BluePills!

BTW, I think I may have seen you on the Duet forums! :smiley:

I have found the issue! :tada:

It turns out that this line in the lv_conf file: # define LV_MEM_SIZE (32U * 1024U) assigned 32kB of my 20kB of RAM to LVGL, hence the obvious issue! I lowered that to 7U * 1024U and that uses up most of my RAM, but still compiles.

I’d like to keep this project running on my BluePill, but it’s looking like that might be a bit unrealistic. According to the on-screen memory monitor, a message box uses 60% of my RAM. If I do have to switch, I have ordered some Raspberry Pi Picos (thanks @zapta for the reminder!). I admit that I’m a bit excited about seeing them! :smirk:

For those who are interested, we recently bought a 1992 MCI bus that was converted into a motorhome by the previous owner. I’m working on adding some neat electronic touches, like an Arduino Pro Mini retractable step controller (finished and on Github), a touchscreen monitor for my water tank levels using LVGL and the cheap Moda tank sensors (this project - I’ll post it on Github when I make notable progress), and an automatic airbag coach leveling system. (Not started yet, but I’ll put it on Github when I do.)

Here’s my Github profile if anyone is interested in the code!

Thanks for your help, and I’m excited about the awesome potential of LVGL! :heart_eyes:

Yes, that’s me. There is a thread there about the stepper analyzer project which is LVGL based.

Saw your other post regarding Raspberry Pico. One option is to use it with platformio which has two sub options, the official Arduino based Pico and the third party WizIO ‘baremetal’ which I am using (it provides access to entire SDK API). I am also using a second Pico as a SWD hardware debugger which works well for me. (I am using Windows, not sure if hardware debugger is already supported on Mac and Linux).

1 Like