Hi LVGL Community,
I am a complete beginner with the LVGL library and I intend to show an animation on my display (ILI9488 controller). I’m using ESP32 board and LVGL 8.3.3.
I was trying to code ILI9488 controller (Intel 8080 Communication interface), I managed to get some code to work. In the following image we can see a vertically oriented animation running smoothly:
However, when I change the orientation to horizontal, what is shown in the following image happens:
The first thing I do is initialize the screen, and this is where I set the orientation by swapping the x and y axes and mirroring (Lines 144 and 145). Then the LVGL library is initialized showing the animated widget. I have been researching and trying to correct this problem without success. Of course I relied on the datasheet of the controller, I don’t know if it will be some initialization instruction or LVGL related issue.
This is the ILI9488 driver code:
#include <driver/gpio.h>
#include <esp_lcd_panel_interface.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_vendor.h>
#include <esp_lcd_panel_ops.h>
#include <esp_lcd_panel_commands.h>
#include <esp_log.h>
#include <esp_rom_gpio.h>
#include <esp_check.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <memory.h>
#include <stdlib.h>
#include <sys/cdefs.h>
static const char *TAG = "ili9488";
typedef struct
{
uint8_t cmd;
uint8_t data[16];
uint8_t data_bytes;
} lcd_init_cmd_t;
typedef struct
{
esp_lcd_panel_t base;
esp_lcd_panel_io_handle_t io;
int reset_gpio_num;
bool reset_level;
int x_gap;
int y_gap;
uint8_t memory_access_control;
uint8_t color_mode;
size_t buffer_size;
uint8_t *color_buffer;
} ili9488_panel_t;
enum ili9488_constants
{
ILI9488_INTRFC_MODE_CTL = 0xB0,
ILI9488_FRAME_RATE_NORMAL_CTL = 0xB1,
ILI9488_INVERSION_CTL = 0xB4,
ILI9488_FUNCTION_CTL = 0xB6,
ILI9488_ENTRY_MODE_CTL = 0xB7,
ILI9488_POWER_CTL_ONE = 0xC0,
ILI9488_POWER_CTL_TWO = 0xC1,
ILI9488_POWER_CTL_THREE = 0xC5,
ILI9488_POSITIVE_GAMMA_CTL = 0xE0,
ILI9488_NEGATIVE_GAMMA_CTL = 0xE1,
ILI9488_ADJUST_CTL_THREE = 0xF7,
ILI9488_COLOR_MODE_16BIT = 0x55,
ILI9488_INTERFACE_MODE_USE_SDO = 0x00,
ILI9488_INTERFACE_MODE_IGNORE_SDO = 0x80,
ILI9488_IMAGE_FUNCTION_DISABLE_24BIT_DATA = 0x00,
ILI9488_WRITE_MODE_BCTRL_DD_ON = 0x28,
ILI9488_FRAME_RATE_60HZ = 0xA0,
ILI9488_INIT_LENGTH_MASK = 0x1F,
ILI9488_INIT_DONE_FLAG = 0xFF
};
static esp_err_t panel_ili9488_del(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
if (ili9488->reset_gpio_num >= 0)
{
gpio_reset_pin(ili9488->reset_gpio_num);
}
ESP_LOGI(TAG, "del ili9488 panel @%p", ili9488);
free(ili9488);
return ESP_OK;
}
static esp_err_t panel_ili9488_reset(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (ili9488->reset_gpio_num >= 0)
{
ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num,
ili9488->reset_level);
// perform hardware reset
gpio_set_level(ili9488->reset_gpio_num, ili9488->reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
ESP_LOGI(TAG, "Setting GPIO:%d to %d", ili9488->reset_gpio_num,
!ili9488->reset_level);
gpio_set_level(ili9488->reset_gpio_num, !ili9488->reset_level);
vTaskDelay(pdMS_TO_TICKS(10));
}
else
{
ESP_LOGI(TAG, "Sending SW_RESET to display");
esp_lcd_panel_io_tx_param(io, LCD_CMD_SWRESET, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(20));
}
return ESP_OK;
}
static esp_err_t panel_ili9488_init(esp_lcd_panel_t *panel)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
lcd_init_cmd_t ili9488_init[] =
{
{ ILI9488_POSITIVE_GAMMA_CTL,
{ 0x00, 0x03, 0x09, 0x08, 0x16,
0x0A, 0x3F, 0x78, 0x4C, 0x09,
0x0A, 0x08, 0x16, 0x1A, 0x0F },
15
},
{ ILI9488_NEGATIVE_GAMMA_CTL,
{ 0x00, 0x16, 0x19, 0x03, 0x0F,
0x05, 0x32, 0x45, 0x46, 0x04,
0x0E, 0x0D, 0x35, 0x37, 0x0F},
15
},
{ ILI9488_POWER_CTL_ONE, { 0x17, 0x15 }, 2 },
{ ILI9488_POWER_CTL_TWO, { 0x41 }, 1 },
{ ILI9488_POWER_CTL_THREE, { 0x00, 0x12, 0x80 }, 3 },
{ LCD_CMD_MADCTL, { ili9488->memory_access_control }, 1 },
{ LCD_CMD_COLMOD, { ili9488->color_mode }, 1 },
{ ILI9488_INTRFC_MODE_CTL, { ILI9488_INTERFACE_MODE_USE_SDO }, 1 },
{ ILI9488_FRAME_RATE_NORMAL_CTL, { ILI9488_FRAME_RATE_60HZ }, 1 },
{ ILI9488_INVERSION_CTL, { 0x02 }, 1 },
{ ILI9488_FUNCTION_CTL, { 0x02, 0x02, 0x3B }, 3},
{ ILI9488_ENTRY_MODE_CTL, { 0xC6 }, 1 },
{ ILI9488_ADJUST_CTL_THREE, { 0xA9, 0x51, 0x2C, 0x02 }, 4 },
{ LCD_CMD_NOP, { 0 }, ILI9488_INIT_DONE_FLAG },
};
ESP_LOGI(TAG, "Initializing ILI9488");
int cmd = 0;
while ( ili9488_init[cmd].data_bytes != ILI9488_INIT_DONE_FLAG )
{
ESP_LOGD(TAG, "Sending CMD: %02x, len: %d", ili9488_init[cmd].cmd,
ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK);
esp_lcd_panel_io_tx_param(
io, ili9488_init[cmd].cmd, ili9488_init[cmd].data,
ili9488_init[cmd].data_bytes & ILI9488_INIT_LENGTH_MASK);
cmd++;
}
// Take the display out of sleep mode.
esp_lcd_panel_io_tx_param(io, LCD_CMD_SLPOUT, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(100));
// Turn on the display.
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0);
vTaskDelay(pdMS_TO_TICKS(100));
ESP_LOGI(TAG, "Initialization complete");
return ESP_OK;
}
#define SEND_COORDS(start, end, io, cmd) \
esp_lcd_panel_io_tx_param(io, cmd, (uint8_t[]) { \
(start >> 8) & 0xFF, \
start & 0xFF, \
((end - 1) >> 8) & 0xFF, \
(end - 1) & 0xFF, \
}, 4)
static esp_err_t panel_ili9488_draw_bitmap(
esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end,
const void *color_data)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
assert((x_start < x_end) && (y_start < y_end) &&
"starting position must be smaller than end position");
esp_lcd_panel_io_handle_t io = ili9488->io;
x_start += ili9488->x_gap;
x_end += ili9488->x_gap;
y_start += ili9488->y_gap;
y_end += ili9488->y_gap;
size_t color_data_len = (x_end - x_start) * (y_end - y_start);
SEND_COORDS(x_start, x_end, io, LCD_CMD_CASET);
SEND_COORDS(y_start, y_end, io, LCD_CMD_RASET);
esp_lcd_panel_io_tx_color(io, LCD_CMD_RAMWR, color_data, color_data_len * 2);
return ESP_OK;
}
#undef SEND_COORDS
static esp_err_t panel_ili9488_invert_color(
esp_lcd_panel_t *panel, bool invert_color_data)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (invert_color_data)
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_INVON, NULL, 0);
}
else
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_INVOFF, NULL, 0);
}
return ESP_OK;
}
static esp_err_t panel_ili9488_mirror(
esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (mirror_x)
{
ili9488->memory_access_control |= LCD_CMD_MX_BIT;
}
else
{
ili9488->memory_access_control &= ~LCD_CMD_MX_BIT;
}
if (mirror_y)
{
ili9488->memory_access_control |= LCD_CMD_MY_BIT;
}
else
{
ili9488->memory_access_control &= ~LCD_CMD_MY_BIT;
}
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1);
return ESP_OK;
}
static esp_err_t panel_ili9488_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
if (swap_axes)
{
ili9488->memory_access_control |= LCD_CMD_MV_BIT;
}
else
{
ili9488->memory_access_control &= ~LCD_CMD_MV_BIT;
}
esp_lcd_panel_io_tx_param(io, LCD_CMD_MADCTL, &ili9488->memory_access_control, 1);
return ESP_OK;
}
static esp_err_t panel_ili9488_set_gap(
esp_lcd_panel_t *panel, int x_gap, int y_gap)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
ili9488->x_gap = x_gap;
ili9488->y_gap = y_gap;
return ESP_OK;
}
static esp_err_t panel_ili9488_disp_on_off(esp_lcd_panel_t *panel, bool on_off)
{
ili9488_panel_t *ili9488 = __containerof(panel, ili9488_panel_t, base);
esp_lcd_panel_io_handle_t io = ili9488->io;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
// In ESP-IDF v4.x the API used false for "on" and true for "off"
// invert the logic to be consistent with IDF v5.x.
on_off = !on_off;
#endif
if (on_off)
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPON, NULL, 0);
}
else
{
esp_lcd_panel_io_tx_param(io, LCD_CMD_DISPOFF, NULL, 0);
}
// give time for the ILI9488 to recover after an on/off command
vTaskDelay(pdMS_TO_TICKS(100));
return ESP_OK;
}
esp_err_t esp_lcd_new_panel_ili9488(
const esp_lcd_panel_io_handle_t io,
const esp_lcd_panel_dev_config_t *panel_dev_config,
const size_t buffer_size,
esp_lcd_panel_handle_t *ret_panel)
{
esp_err_t ret = ESP_OK;
ili9488_panel_t *ili9488 = NULL;
ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG,
err, TAG, "invalid argument");
ili9488 = (ili9488_panel_t *)(calloc(1, sizeof(ili9488_panel_t)));
ESP_GOTO_ON_FALSE(ili9488, ESP_ERR_NO_MEM, err, TAG, "no mem for ili9488 panel");
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_config_t cfg;
memset(&cfg, 0, sizeof(gpio_config_t));
esp_rom_gpio_pad_select_gpio(panel_dev_config->reset_gpio_num);
cfg.pin_bit_mask = BIT64(panel_dev_config->reset_gpio_num);
cfg.mode = GPIO_MODE_OUTPUT;
ESP_GOTO_ON_ERROR(gpio_config(&cfg), err, TAG,
"configure GPIO for RESET line failed");
}
ili9488->color_mode = ILI9488_COLOR_MODE_16BIT;
ili9488->memory_access_control = LCD_CMD_MX_BIT | LCD_CMD_BGR_BIT;
switch (panel_dev_config->color_space)
{
case ESP_LCD_COLOR_SPACE_RGB:
ESP_LOGI(TAG, "Configuring for RGB color order");
ili9488->memory_access_control &= ~LCD_CMD_BGR_BIT;
break;
case ESP_LCD_COLOR_SPACE_BGR:
ESP_LOGI(TAG, "Configuring for BGR color order");
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG,
"Unsupported color mode!");
}
ili9488->io = io;
ili9488->reset_gpio_num = panel_dev_config->reset_gpio_num;
ili9488->reset_level = panel_dev_config->flags.reset_active_high;
ili9488->base.del = panel_ili9488_del;
ili9488->base.reset = panel_ili9488_reset;
ili9488->base.init = panel_ili9488_init;
ili9488->base.draw_bitmap = panel_ili9488_draw_bitmap;
ili9488->base.invert_color = panel_ili9488_invert_color;
ili9488->base.set_gap = panel_ili9488_set_gap;
ili9488->base.mirror = panel_ili9488_mirror;
ili9488->base.swap_xy = panel_ili9488_swap_xy;
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
ili9488->base.disp_off = panel_ili9488_disp_on_off;
#else
ili9488->base.disp_on_off = panel_ili9488_disp_on_off;
#endif
*ret_panel = &(ili9488->base);
ESP_LOGI(TAG, "new ili9488 panel @%p", ili9488);
return ESP_OK;
err:
if (ili9488)
{
if (panel_dev_config->reset_gpio_num >= 0)
{
gpio_reset_pin(panel_dev_config->reset_gpio_num);
}
if (ili9488->color_buffer != NULL)
{
heap_caps_free(ili9488->color_buffer);
}
free(ili9488);
}
return ret;
}
This is the animation code using LVGL 8.3.3:
#include <esp_err.h>
#include <esp_freertos_hooks.h>
#include <esp_log.h>
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_vendor.h>
#include <esp_lcd_panel_ops.h>
#include <esp_lcd_ili9488.h>
#include <esp_timer.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <lvgl.h>
#include <stdio.h>
#include "sdkconfig.h"
// Uncomment the following line to enable using double buffering of LVGL color
// data.
// #define USE_DOUBLE_BUFFERING 1
#define LCD_PIN_NUM_DATA0 19
#define LCD_PIN_NUM_DATA1 21
#define LCD_PIN_NUM_DATA2 26
#define LCD_PIN_NUM_DATA3 22
#define LCD_PIN_NUM_DATA4 12
#define LCD_PIN_NUM_DATA5 33
#define LCD_PIN_NUM_DATA6 25
#define LCD_PIN_NUM_DATA7 27
#define LCD_PIN_NUM_PCLK 18
#define LCD_PIN_NUM_CS 2
#define LCD_PIN_NUM_DC 5
#define LCD_PIN_NUM_RST 4
#define LCD_PIN_NUM_BK_LIGHT 36
#define LCD_CMD_BITS 8
#define LCD_PARAM_BITS 8
#define LCD_HORIZONTAL_PIXELS 320
#define LCD_VERTICAL_PIXELS 480
static const char *TAG = "main";
// Default to 50 lines of color data
static const size_t LV_BUFFER_SIZE = LCD_HORIZONTAL_PIXELS * 100;
static const int LVGL_UPDATE_PERIOD_MS = 5;
static esp_lcd_panel_io_handle_t lcd_io_handle = NULL;
static esp_lcd_panel_handle_t lcd_handle = NULL;
static lv_disp_draw_buf_t lv_disp_buf;
static lv_disp_drv_t lv_disp_drv;
static lv_disp_t *lv_display = NULL;
static lv_color_t *lv_buf_1 = NULL;
static lv_color_t *lv_buf_2 = NULL;
static lv_obj_t *meter = NULL;
static lv_style_t style_screen;
static void update_meter_value(void *indic, int32_t v)
{
lv_meter_set_indicator_end_value(meter, indic, v);
}
static bool notify_lvgl_flush_ready(esp_lcd_panel_io_handle_t panel_io,
esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
{
lv_disp_drv_t *disp_driver = (lv_disp_drv_t *)user_ctx;
lv_disp_flush_ready(disp_driver);
return false;
}
static void lvgl_flush_cb(lv_disp_drv_t *drv, const lv_area_t *area, lv_color_t *color_map)
{
esp_lcd_panel_handle_t panel_handle = (esp_lcd_panel_handle_t) drv->user_data;
int offsetx1 = area->x1;
int offsetx2 = area->x2;
int offsety1 = area->y1;
int offsety2 = area->y2;
esp_lcd_panel_draw_bitmap(panel_handle, offsetx1, offsety1, offsetx2 + 1, offsety2 + 1, color_map);
}
static void IRAM_ATTR lvgl_tick_cb(void *param)
{
lv_tick_inc(LVGL_UPDATE_PERIOD_MS);
}
void initialize_display()
{
esp_lcd_i80_bus_handle_t i80_bus = NULL;
esp_lcd_i80_bus_config_t bus_config = {
.clk_src = LCD_CLK_SRC_DEFAULT,
.dc_gpio_num = LCD_PIN_NUM_DC,
.wr_gpio_num = LCD_PIN_NUM_PCLK,
.data_gpio_nums = {
LCD_PIN_NUM_DATA0,
LCD_PIN_NUM_DATA1,
LCD_PIN_NUM_DATA2,
LCD_PIN_NUM_DATA3,
LCD_PIN_NUM_DATA4,
LCD_PIN_NUM_DATA5,
LCD_PIN_NUM_DATA6,
LCD_PIN_NUM_DATA7,
},
.bus_width = 8,
.max_transfer_bytes = LCD_HORIZONTAL_PIXELS * 100 * sizeof(uint16_t) // 40
};
esp_lcd_panel_io_i80_config_t io_config = {
.cs_gpio_num = LCD_PIN_NUM_CS,
.pclk_hz = 10000000,
.trans_queue_depth = 10,
.dc_levels = {
.dc_idle_level = 0,
.dc_cmd_level = 0,
.dc_dummy_level = 0,
.dc_data_level = 1,
},
.on_color_trans_done = notify_lvgl_flush_ready,
.user_ctx = &lv_disp_drv,
.lcd_cmd_bits = LCD_CMD_BITS,
.lcd_param_bits = LCD_PARAM_BITS,
.flags = {
.swap_color_bytes = !LV_COLOR_16_SWAP, // Swap can be done in LvGL (default) or DMA
}
};
const esp_lcd_panel_dev_config_t lcd_config =
{
.reset_gpio_num = LCD_PIN_NUM_RST,
.rgb_endian = LCD_RGB_ENDIAN_BGR,
.bits_per_pixel = 16,
.flags =
{
.reset_active_high = 0
},
.vendor_config = NULL
};
ESP_ERROR_CHECK(esp_lcd_new_i80_bus(&bus_config, &i80_bus));
ESP_ERROR_CHECK(esp_lcd_new_panel_io_i80(i80_bus, &io_config, &lcd_io_handle));
ESP_ERROR_CHECK(esp_lcd_new_panel_ili9488(lcd_io_handle, &lcd_config, LV_BUFFER_SIZE, &lcd_handle));
ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_handle));
ESP_ERROR_CHECK(esp_lcd_panel_invert_color(lcd_handle, true));
ESP_ERROR_CHECK(esp_lcd_panel_swap_xy(lcd_handle, false));
ESP_ERROR_CHECK(esp_lcd_panel_mirror(lcd_handle, true, false)); // true false
ESP_ERROR_CHECK(esp_lcd_panel_set_gap(lcd_handle, 0, 0));
ESP_ERROR_CHECK(esp_lcd_panel_disp_on_off(lcd_handle, true));
}
void initialize_lvgl()
{
ESP_LOGI(TAG, "Initializing LVGL");
lv_init();
ESP_LOGI(TAG, "Allocating %zu bytes for LVGL buffer", LV_BUFFER_SIZE * sizeof(lv_color_t));
lv_buf_1 = (lv_color_t *)heap_caps_malloc(LV_BUFFER_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);
#if USE_DOUBLE_BUFFERING
ESP_LOGI(TAG, "Allocating %zu bytes for second LVGL buffer", LV_BUFFER_SIZE * sizeof(lv_color_t));
lv_buf_2 = (lv_color_t *)heap_caps_malloc(LV_BUFFER_SIZE * sizeof(lv_color_t), MALLOC_CAP_DMA);
#endif
ESP_LOGI(TAG, "Creating LVLG display buffer");
lv_disp_draw_buf_init(&lv_disp_buf, lv_buf_1, lv_buf_2, LV_BUFFER_SIZE);
ESP_LOGI(TAG, "Initializing %dx%d display", LCD_HORIZONTAL_PIXELS, LCD_VERTICAL_PIXELS);
lv_disp_drv_init(&lv_disp_drv);
lv_disp_drv.hor_res = LCD_HORIZONTAL_PIXELS;
lv_disp_drv.ver_res = LCD_VERTICAL_PIXELS;
lv_disp_drv.flush_cb = lvgl_flush_cb;
lv_disp_drv.draw_buf = &lv_disp_buf;
lv_disp_drv.user_data = lcd_handle;
lv_display = lv_disp_drv_register(&lv_disp_drv);
ESP_LOGI(TAG, "Creating LVGL tick timer");
const esp_timer_create_args_t lvgl_tick_timer_args =
{
.callback = &lvgl_tick_cb,
.name = "lvgl_tick"
};
esp_timer_handle_t lvgl_tick_timer = NULL;
ESP_ERROR_CHECK(esp_timer_create(&lvgl_tick_timer_args, &lvgl_tick_timer));
ESP_ERROR_CHECK(esp_timer_start_periodic(lvgl_tick_timer, LVGL_UPDATE_PERIOD_MS * 1000));
}
void create_demo_ui()
{
lv_obj_t *scr = lv_disp_get_scr_act(NULL);
// Set the background color of the display to black.
lv_style_init(&style_screen);
lv_style_set_bg_color(&style_screen, lv_color_black());
lv_obj_add_style(lv_scr_act(), &style_screen, LV_STATE_DEFAULT);
// Create a meter which can be animated.
meter = lv_meter_create(scr);
lv_obj_center(meter);
lv_obj_set_size(meter, 200, 200);
// Add a scale first
lv_meter_scale_t *scale = lv_meter_add_scale(meter);
lv_meter_set_scale_ticks(meter, scale, 41, 2, 10, lv_palette_main(LV_PALETTE_GREY));
lv_meter_set_scale_major_ticks(meter, scale, 8, 4, 15, lv_color_black(), 10);
lv_meter_indicator_t *indic;
// Add a blue arc to the start
indic = lv_meter_add_arc(meter, scale, 3, lv_palette_main(LV_PALETTE_BLUE), 0);
lv_meter_set_indicator_start_value(meter, indic, 0);
lv_meter_set_indicator_end_value(meter, indic, 20);
// Make the tick lines blue at the start of the scale
indic = lv_meter_add_scale_lines(meter, scale, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_BLUE), false, 0);
lv_meter_set_indicator_start_value(meter, indic, 0);
lv_meter_set_indicator_end_value(meter, indic, 20);
// Add a red arc to the end
indic = lv_meter_add_arc(meter, scale, 3, lv_palette_main(LV_PALETTE_RED), 0);
lv_meter_set_indicator_start_value(meter, indic, 80);
lv_meter_set_indicator_end_value(meter, indic, 100);
// Make the tick lines red at the end of the scale
indic = lv_meter_add_scale_lines(meter, scale, lv_palette_main(LV_PALETTE_RED), lv_palette_main(LV_PALETTE_RED), false, 0);
lv_meter_set_indicator_start_value(meter, indic, 80);
lv_meter_set_indicator_end_value(meter, indic, 100);
// Add a needle line indicator
indic = lv_meter_add_needle_line(meter, scale, 4, lv_palette_main(LV_PALETTE_GREY), -10);
// Create an animation to set the value
lv_anim_t a;
lv_anim_init(&a);
lv_anim_set_exec_cb(&a, update_meter_value);
lv_anim_set_var(&a, indic);
lv_anim_set_values(&a, 0, 100);
lv_anim_set_time(&a, 2000);
lv_anim_set_repeat_delay(&a, 100);
lv_anim_set_playback_time(&a, 500);
lv_anim_set_playback_delay(&a, 100);
lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
lv_anim_start(&a);
}
void app_main()
{
initialize_display();
initialize_lvgl();
create_demo_ui();
while (1)
{
vTaskDelay(pdMS_TO_TICKS(10));
lv_timer_handler();
}
}
You can download the complete project from the link below, just add the lvgl library inside the components folder before compiling.
ILI9488Driver.zip (20.4 KB)
Any kind of help will be appreciated.
Thanks in advance.
Best regards.