lvgl 页面管理器

已于 2023-11-13 08:30:25 修改
阅读量1.4k 收藏 10
点赞数 1
分类专栏： LVGL 文章标签： lvgl 页面管理 嵌入式 stm32
于 2023-10-13 19:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42378319/article/details/133802869
版权

lv_scr_mgr

lvgl 界面管理器

适配 lvgl 8.3

  • 降低界面之间的耦合
  • 使用较小的内存，界面切换后会自动释放内存
  • 内存泄漏检测
    请添加图片描述

使用方法

  1. 在lv_scr_mgr_port.h 中创建一个枚举，用于界面ID
  2. 为每个界面创建一个页面管理器句柄
  3. 将界面句柄添加到 lv_scr_mgr_port.c 数组中
  4. 在 lv_init() 后，对页面管理器进行初始化 lv_scr_mgr_init(NULL);
  5. 使用 lv_scr_mgr_switch 设置初始根界面
  6. 使用 lv_scr_mgr_push lv_scr_mgr_pop 对界面进行操作

git地址

git地址
gitee

  • lv_scr_mgr.c
/**
  *******************************CopyRight  ************************************
  * @file    lv_scr_mgr.c
  * @author  zyf
  * @date    2023-10-11 13:4:36
  * @brief   lvgl 页面管理器
  *          
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "lvgl.h"
#include "lv_scr_mgr.h"

typedef struct
{
    uint32_t                     scr_cnt; 
    void*                        param;
    const lv_scr_mgr_handle_t    **handles;
#if LV_SCR_MGR_PRINTF_MEM
    uint32_t                     *max_mem;
#endif
}scr_mgr_list_handle_t;


static scr_mgr_list_handle_t     mgr_list;
static lv_scr_mgr_stack_node_t*      mgr_stack_top = NULL;
static lv_scr_mgr_stack_node_t*      mgr_stack_root = NULL;

static const lv_scr_mgr_handle_t* find_handle_by_id(uint32_t id)
{
    for (int i = 0; i < mgr_list.scr_cnt; i++)
    {
        if (mgr_list.handles[i]->scr_id == id)
        {
            return mgr_list.handles[i];
        }
    }
    return NULL;
}
#if LV_SCR_MGR_PRINTF_MEM
static uint32_t* find_mem_addr_by_id(uint32_t id)
{
    for (int i = 0; i < mgr_list.scr_cnt; i++)
    {
        if (mgr_list.handles[i]->scr_id == id)
        {
            return &mgr_list.max_mem[i];
        }
    }
    return NULL;
}

static void mem_max_printf(uint32_t id)
{
    static uint32_t mem_max = 0;
    lv_mem_monitor_t mon;
    lv_mem_monitor(&mon);
    if (mon.total_size - mon.free_size > mem_max)
    {
        mem_max = mon.total_size - mon.free_size;
        LV_LOG_USER("used: %d (%d %%), frag: %d %%, biggest free: %d\n", mem_max,
            mon.used_pct,
            mon.frag_pct,
            (int)mon.free_biggest_size);
    }
}

static void page_mem_max_printf(uint32_t id)
{
    lv_mem_monitor_t mon;
    lv_mem_monitor(&mon);
    /* 当前界面最大使用内存 */
    uint32_t* page_max_mem = find_mem_addr_by_id(id);
    if (mon.total_size - mon.free_size > *page_max_mem)
    {
        *page_max_mem = mon.total_size - mon.free_size;
        LV_LOG_USER("page id %d, used: %d (%d %%), frag: %d %%, biggest free: %d\n", id, *page_max_mem,
            mon.used_pct,
            mon.frag_pct,
            (int)mon.free_biggest_size);
    }
}


static void anim_mem_max_printf(lv_event_t* e)
{
    lv_event_code_t event_code = lv_event_get_code(e);
    if (event_code == LV_EVENT_SCREEN_LOADED)
    {
        page_mem_max_printf((uint32_t)lv_event_get_user_data(e));
    }
}
#endif

static void scr_mgr_stack_free(void)
{
    lv_scr_mgr_stack_node_t* stack_node = NULL;

    /* 释放界面栈 */
    while (NULL != mgr_stack_top)
    {
        stack_node = mgr_stack_top->prev;
        if(mgr_stack_top->handle->scr_destroy)
            mgr_stack_top->handle->scr_destroy();
        lv_mem_free((void*)mgr_stack_top);
        mgr_stack_top = stack_node;
    }
    mgr_stack_root = NULL;
}

/**
 * @brief 入栈
 * @param tag 要入栈的句柄
 * @return 栈顶句柄
*/
static lv_scr_mgr_stack_node_t* scr_mgr_stack_push(const lv_scr_mgr_handle_t* tag)
{
    lv_scr_mgr_stack_node_t* stack_node = NULL;
    stack_node = lv_mem_alloc(sizeof(lv_scr_mgr_stack_node_t));
    LV_ASSERT_MALLOC(stack_node);
    stack_node->handle = tag;
    stack_node->next = NULL;
    if (stack_node->handle->scr_first_create)
    {
        stack_node->handle->scr_first_create();
    }

    if (tag->scr_create)
    {
        stack_node->scr = tag->scr_create(stack_node->handle->scr_id, mgr_list.param);
    }
    else
    {
        LV_LOG_ERROR("no create fun!");
    }

    if (NULL == mgr_stack_top)
    {
        stack_node->prev = NULL;
        mgr_stack_root = stack_node;
    }
    else
    {
        stack_node->prev = mgr_stack_top;
        mgr_stack_top->next = stack_node;
    }
    mgr_stack_top = stack_node;
    return stack_node;
}

static int32_t scr_mgr_stack_pop(int32_t n)
{
    lv_scr_mgr_stack_node_t* stack_node = NULL;
    int32_t i = n;

    if ((NULL == mgr_stack_top) || (NULL == mgr_stack_top->prev))
    {
        return 0;
    }

    while (i)
    {
        if ((NULL == mgr_stack_top) || (NULL == mgr_stack_top->prev))
        {
            break;
        }

        stack_node = mgr_stack_top->prev;
        if (mgr_stack_top->handle->scr_destroy)
        {
            mgr_stack_top->handle->scr_destroy();
        }
        lv_mem_free((void*)mgr_stack_top);
        mgr_stack_top = stack_node;
        i--;
    }

    if (NULL != mgr_stack_top->handle->scr_create)
    {
        mgr_stack_top->scr = mgr_stack_top->handle->scr_create(mgr_stack_top->handle->scr_id, mgr_list.param);
    }
    else
    {
        LV_LOG_ERROR("no create fun!");
    }

    if (i)
    {
        LV_LOG_WARN("stack pop %d, but stack is %d", n, n-i);
    }
    return n - i;
}

/**
 * @brief 切换界面
 * @param cur_scr 当前界面
 * @param stack_node 目标界面句柄
 * @param anim 切换界面动画开关
 *             关闭界面切换动画，切换界面时会先创建一个新的空界面，切换到空界面后，
 *             删除之前的界面，然后再创建切换到新界面，最后再删除中间界面。会节省内存。
 *             关闭界面切换动画，切换界面时直接创建新界面，然后再用动画切换到新界面。
 *
 * @return true
*/
bool scr_mgr_switch(lv_obj_t* cur_scr, lv_scr_mgr_stack_node_t* stack_node, bool anim)
{
    lv_scr_load_anim_t load_anim = LV_SCR_MGR_LOAD_ANIM_DEFAULT;
    lv_obj_t* tmp_scr = NULL;

    if (anim)
    {
        if ((stack_node->handle->anim_type != LV_SCR_LOAD_ANIM_NONE) && (LV_SCR_LOAD_ANIM_OUT_BOTTOM >= stack_node->handle->anim_type))
        {
            load_anim = stack_node->handle->anim_type;
        }

#if LV_SCR_MGR_PRINTF_MEM
        mem_max_printf(stack_node->handle->scr_id);
        lv_obj_add_event_cb(stack_node->scr, anim_mem_max_printf, LV_EVENT_SCREEN_LOADED, (void*)stack_node->handle->scr_id);
#endif

        lv_scr_load_anim(stack_node->scr, load_anim, LV_SCR_MGR_LOAD_ANIM_TIME, LV_SCR_MGR_LOAD_ANIM_DELAY, true);
    }
    else
    {
        if (NULL != cur_scr)
        {
            tmp_scr = lv_obj_create(NULL);
            lv_scr_load(tmp_scr);
            lv_obj_del(cur_scr);
            cur_scr = NULL;
        }

        lv_scr_load(stack_node->scr);

#if LV_SCR_MGR_PRINTF_MEM
        mem_max_printf(stack_node->handle->scr_id);
        page_mem_max_printf(stack_node->handle->scr_id);
#endif
        if (NULL != tmp_scr)
        {
            lv_obj_del(tmp_scr);
        }
    }
    return true;
}

/**
 * @brief 初始化界面管理器
 * @param param 创建界面时的参数
 * @return 
*/
bool lv_scr_mgr_init(void* param)
{
    mgr_list.param = param;
#if LV_SCR_MGR_REG_ENABLE
    extern const lv_scr_mgr_handle_t* scr_mgr_scr_mgr_start;
    extern const lv_scr_mgr_handle_t* scr_mgr_scr_mgr_end;
    const lv_scr_mgr_handle_t** item = &scr_mgr_scr_mgr_start;
    item++;
    mgr_list.handles = item;
    mgr_list.scr_cnt = 0;
    for(;item < &scr_mgr_scr_mgr_end; item++)
    {
        mgr_list.scr_cnt++;  
    }
#else
    mgr_list.scr_cnt = lv_scr_mgr_get_cnt();
    mgr_list.handles  = lv_scr_mgr_get_handles();
#endif    

    if (0 == mgr_list.scr_cnt)
    {
        LV_LOG_ERROR("no screen!");
        return false;
    }

#if LV_SCR_MGR_PRINTF_MEM
    mgr_list.max_mem = lv_mem_alloc(mgr_list.scr_cnt * sizeof(uint32_t*));
    LV_ASSERT(mgr_list.max_mem);
    memset(mgr_list.max_mem, 0, mgr_list.scr_cnt * sizeof(uint32_t*));
#endif
    return true;
}

void lv_scr_mgr_deinit(void)
{
    mgr_list.param = NULL;
#if LV_SCR_MGR_PRINTF_MEM
    lv_mem_free(mgr_list.max_mem);
#endif
    scr_mgr_stack_free();
}

void lv_scr_mgr_param_set(void* param)
{
    mgr_list.param = param;
}

void* lv_scr_mgr_param_get(void)
{
    return mgr_list.param;
}

/**
 * @brief 设置根界面
 * @param id 根界面序号
 * @param anim 动画开关
 * @return 
*/
bool lv_scr_mgr_switch(uint32_t id, bool anim)
{
    const lv_scr_mgr_handle_t* tag_handle = find_handle_by_id(id);
    const lv_scr_mgr_handle_t* cur_handle = NULL;
    lv_scr_mgr_stack_node_t* stack_node = NULL;
    lv_obj_t* cur_scr = NULL;
    
    
    if (NULL == tag_handle)
    {
        LV_LOG_ERROR("no screen, id %d", id);
        return false;
    }


    if (NULL != mgr_stack_top)
    {
        /* 栈内有界面 */
        cur_handle = mgr_stack_top->handle;
        cur_scr = mgr_stack_top->scr;
    }
    else
    {
        cur_scr = lv_scr_act();
    }

    scr_mgr_stack_free();

    if ((NULL == cur_handle) || (tag_handle->scr_id == cur_handle->scr_id))
    {
        /* 没有界面切换，不使用动画效果 */
        anim = false;
    }
    stack_node = scr_mgr_stack_push(tag_handle);

    return scr_mgr_switch(cur_scr, stack_node, anim);
}

/**
 * @brief 入栈一个新的界面
 * @param id 
 * @param anim 
 * @return 
*/
bool lv_scr_mgr_push(uint32_t id, bool anim)
{
    const lv_scr_mgr_handle_t* tag_handle = find_handle_by_id(id);
    lv_scr_mgr_stack_node_t* stack_node = NULL;
    lv_obj_t* cur_scr = NULL;

    if (NULL == tag_handle)
    {
        LV_LOG_ERROR("no screen, id %d", id);
        return false;
    }

    if ((NULL == mgr_stack_top) || (NULL == mgr_stack_root))
    {
        LV_LOG_ERROR("no root screen, please use lv_scr_mgr_switch create root screen");
        return false;
    }
    cur_scr = mgr_stack_top->scr;
    stack_node = scr_mgr_stack_push(tag_handle);

    return scr_mgr_switch(cur_scr, stack_node, anim);
}

/**
 * @brief 出栈n个界面
 * @param n 如果栈内界面没有n个，则返回根界面
 * @param anim 
 * @return 
*/
bool lv_scr_mgr_popn(uint32_t n, bool anim)
{
    lv_obj_t* cur_scr = NULL;

    if ((mgr_stack_top == NULL) || (mgr_stack_top->prev == NULL))
    {
        return false;
    }
    cur_scr = mgr_stack_top->scr;

    scr_mgr_stack_pop(n);

    return scr_mgr_switch(cur_scr, mgr_stack_top, anim);
}

/**
 * @brief 出栈一个界面
 * @param anim 
 * @return 
*/
bool lv_scr_mgr_pop(bool anim)
{
    return lv_scr_mgr_popn(1, anim);
}


/**
 * @brief 退回到根界面
 * @param anim 
 * @return 
*/
bool lv_scr_mgr_pop_root(bool anim)
{
    lv_scr_mgr_stack_node_t* stack_node = NULL;
    lv_scr_mgr_stack_node_t* stack_top = NULL;
    uint32_t cnt = 0;
    if (NULL == mgr_stack_root || NULL == mgr_stack_top)
    {
        return false;
    }

    stack_top = mgr_stack_top;

    while (stack_top != NULL)
    {
        cnt++;
        stack_node = stack_top->prev;
        stack_top = stack_node;
    }

    return lv_scr_mgr_popn(cnt-1, anim);
}

/**
 * @brief 获取当前界面id
 * @param  
 * @return 
*/
int32_t lv_scr_mgr_get_cur_id(void)
{
    if (NULL != mgr_stack_top && NULL != mgr_stack_top->handle)
    {
        return mgr_stack_top->handle->scr_id;
    }
    else
    {
        return -1;
    }
}

/**
 * @brief 获取根界面id
 * @param
 * @return
*/
int32_t lv_scr_mgr_get_root_id(void)
{
    if (NULL != mgr_stack_root && NULL != mgr_stack_root->handle)
    {
        return mgr_stack_root->handle->scr_id;
    }
    else
    {
        return -1;
    }
}
/************************ (C) COPYRIGHT ***********END OF FILE*****************/
  • lv_scr_mgr.h
/**
  *******************************CopyRight  ************************************
  * @file    lv_scr_mgr.h
  * @author  zyf
  * @date    2023-10-11 9:31:49
  * @brief   lvgl 页面管理器
  *          
  ******************************************************************************
  */
#ifndef _LV_SCR_MGR_H_
#define _LV_SCR_MGR_H_

/* Includes ------------------------------------------------------------------*/
#include "stdint.h"
#include "lvgl.h"

#ifdef __cplusplus
extern "C" {
#endif
 
/*!<  界面切换动画默认值
 */
#define LV_SCR_MGR_LOAD_ANIM_DEFAULT   LV_SCR_LOAD_ANIM_MOVE_LEFT
#define LV_SCR_MGR_LOAD_ANIM_TIME      500
#define LV_SCR_MGR_LOAD_ANIM_DELAY     0

/*!< 内存泄漏检测 注意，页面管理器的push操作也会申请动态内存
 * 如果使用动画，则需要将 lv_disp.c 中的 scr_anim_ready 改为如下
    static void scr_anim_ready(lv_anim_t * a)
    {
        lv_disp_t * d = lv_obj_get_disp(a->var);

        lv_event_send(d->prev_scr, LV_EVENT_SCREEN_UNLOADED, NULL);

        if(d->prev_scr && d->del_prev) lv_obj_del(d->prev_scr);
        d->prev_scr = NULL;
        d->draw_prev_over_act = false;
        d->scr_to_load = NULL;
        lv_event_send(d->act_scr, LV_EVENT_SCREEN_LOADED, NULL);
        lv_obj_remove_local_style_prop(a->var, LV_STYLE_OPA, 0);
        lv_obj_invalidate(d->act_scr);
    }
 */
#define LV_SCR_MGR_PRINTF_MEM          1   

/* 使用分散加载的方式 将 lv_scr_mgr_handle_t 存放在特定段，
 * 用户创建 lv_scr_mgr_handle_t 后可以在后面直接 使用 LV_SCR_MGR_REG() 对界面句柄进行注册
 * 而不用将 界面句柄 添加到 lv_scr_mgr_port.c 数组中
 */
#define LV_SCR_MGR_REG_ENABLE          0





typedef struct
{
    uint32_t scr_id;                       /*!< id */
    lv_scr_load_anim_t      anim_type;     /*!< 切换动画类型 如果为空，则使用 LV_SCR_MGR_LOAD_ANIM_DEFAULT */
    void (*scr_first_create)(void);        /*!< lv_scr_mgr_switch  lv_scr_mgr_push 函数会调用该创建函数 pop则不会调用 可以方便实现pop记住焦点 而push使用默认焦点 */
    lv_obj_t* (*scr_create) (const uint32_t id, void* param); /*!< 创建界面，创建界面时不要使用 lv_scr_mgr_xxx 函数 */
    void (*scr_destroy)(void);             /*!< 删除界面的回调函数，一般用于删除如 lv_timer 等不会随界面自动删除的资源 */
}lv_scr_mgr_handle_t;

typedef struct _lv_scr_mgr_stack_node_t
{
    const lv_scr_mgr_handle_t* handle;
    lv_obj_t* scr;
    struct _lv_scr_mgr_stack_node_t* prev;
    struct _lv_scr_mgr_stack_node_t* next;
}lv_scr_mgr_stack_node_t;

#include "lv_scr_mgr_port.h"
#if LV_SCR_MGR_REG_ENABLE
#define  ANONY_CONN(type, var)   type  var
#define  ANONY_DEF(type,prefix)  ANONY_CONN(type, prefix)
#define  ANONY_TYPE(type,prefix) ANONY_DEF(type, prefix)

#if defined(__CC_ARM) || defined(__GNUC__) /* ARM,GCC*/
#define SECTION(x)                  __attribute__((section(x)))
#define USED                        __attribute__((used))
#elif defined (__ICCARM__)              /*IAR */
#define SECTION(x)                  @ x
#define USED                        __root
#else
#error "Current tool chain haven't supported yet!"
#endif


#define _LV_SCR_MGR_REG(handle, level)           \
    USED ANONY_TYPE(const lv_scr_mgr_handle_t*, scr_mgr_##handle)\
    SECTION("scr_mgr."level) = &(handle)
    
#define LV_SCR_MGR_REG(handle)  _LV_SCR_MGR_REG(handle, "1") 
#else
#define LV_SCR_MGR_REG(handle)     
#endif
    

bool lv_scr_mgr_init(void* param);
void lv_scr_mgr_deinit(void);
void lv_scr_mgr_param_set(void* param);
void* lv_scr_mgr_param_get(void);

bool lv_scr_mgr_switch(uint32_t id, bool anim);
bool lv_scr_mgr_push(uint32_t id, bool anim);
bool lv_scr_mgr_popn(uint32_t n, bool anim);
bool lv_scr_mgr_pop(bool anim);
bool lv_scr_mgr_pop_root(bool anim);
int32_t lv_scr_mgr_get_cur_id(void);
int32_t lv_scr_mgr_get_root_id(void);
#ifdef __cplusplus
}
#endif

#endif /* _LV_SCR_MGR_H_ */

/************************ (C) COPYRIGHT *****END OF FILE*****************/
  • lv_scr_mgr_port.c
/**
  *******************************CopyRight  ************************************
  * @file    lv_scr_mgr_port.c
  * @author  zyf
  * @date    2023-10-11 13:51:24
  * @brief   lvgl 页面管理器 接口
  *          
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "lv_scr_mgr.h"
#include "lv_scr_mgr_port.h"


#if LV_SCR_MGR_REG_ENABLE

/* 无需用户修改 */
const lv_scr_mgr_handle_t  scr_mgr_start = {0};
_LV_SCR_MGR_REG(scr_mgr_start, "0");
const lv_scr_mgr_handle_t  scr_mgr_end = {0};
_LV_SCR_MGR_REG(scr_mgr_end, "2");

#else

/* 需要用户添加自己的界面句柄 */
extern const lv_scr_mgr_handle_t s_scr_mgr_handle_test1;
extern const lv_scr_mgr_handle_t s_scr_mgr_handle_test2;
extern const lv_scr_mgr_handle_t s_scr_mgr_handle_test3;
static const lv_scr_mgr_handle_t* scr_mgr_handles[] = {
    & s_scr_mgr_handle_test1,
    & s_scr_mgr_handle_test2,
    & s_scr_mgr_handle_test3,
};

uint32_t lv_scr_mgr_get_cnt(void)
{
    return sizeof(scr_mgr_handles) / sizeof(scr_mgr_handles[0]);
}

const lv_scr_mgr_handle_t** lv_scr_mgr_get_handles(void)
{
    return scr_mgr_handles;
}

#endif

/************************ (C) COPYRIGHT ***********END OF FILE*****************/
  • lv_scr_mgr_port.h
/**
  *******************************CopyRight  ************************************
  * @file    lv_scr_mgr_port.h
  * @author  zyf
  * @date    2023-10-11 13:51:23
  * @brief   lvgl 页面管理器 接口
  *          
  ******************************************************************************
  */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef _LV_SCR_MGR_PORT_H_
#define _LV_SCR_MGR_PORT_H_

/* Includes ------------------------------------------------------------------*/
#include "lvgl.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef enum
{
    eScreenUITest1 = 0,
    eScreenUITest2,
    eScreenUITest3
}lv_scr_mgr_id_e;

#if !LV_SCR_MGR_REG_ENABLE
uint32_t lv_scr_mgr_get_cnt(void);
const lv_scr_mgr_handle_t** lv_scr_mgr_get_handles(void);
#endif
#ifdef __cplusplus
}
#endif

#endif /* _LV_SCR_MGR_PORT_H_ */

/************************ (C) COPYRIGHT ***********END OF FILE*****************/
不咸不要钱
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【定制功能】LVGL 页面管理
Bigan(安)的博客
09-29 4058
页面管理的主要针对实际复杂的UI项目的。支持多页面管理，包含页面跳转和返回（主要是方便项目功能管理）支持后台页面自动销毁、前台页面自动创建（主要是节约资源使用）支持语言切换逻辑（页面重建功能）支持主题切换逻辑支持页面切换动画效果首先，页面管理是针对act_src图层来讲的。仅在screens数组中供act_src切换的对象树才会被此页面管理功能所管理。这意味着，如果top_layer或者sys_layer图层上，有页面需要重建时，需要特殊处理（实际项目中top_layer或者。
LVGL 官方设计器 V1.05版本
05-08
1. LVGL 官方设计器 V1.05版本 2. 无需账号即可使用 3. 纯英文版 4. 支持控件少，但是比较丝滑，仿真比NXP的快
【LVGL】页面管理框架
涛涛子的博客
02-27 3223
我们在实际使用 LVGL 完成一些项目时，通常需要展示不止一个页面，此时这些页面要如何更好的进行管理成为了一个需要解决的问题，如果处理不当，在资源短缺的嵌入式设备中很可能会因为过多页面的加载但却没有及时释放造成系统的崩溃。现在就为大家展示一下我所构建的页面管理框架，如果设计上有存在什么问题，欢迎留言讨论。
LVGL自定义组件__页面指示器
我的博客
12-06 1268
LVGL对硬件的要求非常低，使用其自带的组件能够搭建出精美的界面，动效也很棒。但是如过移植到Linux平台下，开发稍微复杂的应用项目，那些组件就远远不够用了。为此需要自己自定义一些组件，以方便实用。为此，尝试开发了一个页面指示器，先看效果： circles.h circles.c 使用方法 项目根目录下，新建文件夹，把上面的两个文件放进去 修改： 要使用时引入头文件 可以使用自带的Demo快速预览，具体使用方法可以参考Demo函数 配置 参考demo函数初始化配置即可：由于刚刚上手lvgl
LVGL--窗口部件(lv_win)
最新发布
m0_63472758的博客
02-28 243
窗口部件可以作为一个容器，可以展现不同功能的页面。
LVGL8.3 --lv_bar 进度条
smicd的博客
01-30 1201
进度条对象有一个背景和一个指示器。指示器的宽度根据进度条的当前值自动设置。如果设置进度条的宽度小于其高度，就可以创建出垂直摆放的进度条。可以通过设置进度条的值，从而改变指标的开始位置。进度条的PART与style都比较简单和明确，本文重点在于对进度条模式mode的理解。
LVGL 界面跳转逻辑的设计与实现
ShallowGreen的博客
10-03 8688
LVGL 中没有关于界面调度相关的接口，这一块需自己定义界面的跳转逻辑，本文章分享的是一种界面跳转的思路与实现。
visual studio运行littlevgl(lvgl)示例
飘雪冰峰的博客
08-07 6149
visual studio运行littlevgl(lvgl)示例 LVGL 官方已经提供了在 Visual Studio 2017 上面进行lvgl仿真的示例了，这也大大方便了我们开发测试。 如何获取 lvgl 的visual studio 工程源码 直接在git命令行运行以下命令即可。 git clone --recurse-submodules https://github.com/lvgl/lv_sim_visual_studio_sdl.git 或者也可以从以下链接获取。 下载链接 测试 下载完
基于LVGL的界面管理机制
wsqxfx的博客
12-01 632
1.lvgl资源连接，从GitHub上可以直接搜索lvgl,可以搜索到各个版本的资源连接，连接如下：https://github.com/lvgl/lvgl。基于lvgl的实现，为了方便页面的管理和实现，使用了面向对象的方式进行界面的管理和实现，方便后续作为模板化生成界面，新增界面和维护界面非常方便。我们界面总共有100个左右的界面，所以界面句柄的管理使用了堆栈进行页面句柄的入栈出栈操作，源码如下。lvgl是一款轻量级的嵌入式开源界面代码，广泛用于图形化的界面操作，控件丰富。在分支里选择你所需要的工程包。
lvgl页面管理 简单实现
weixin_44678052的博客
12-06 4727
在lvgl使用的过程中，最初的时候，肯定都会遇到这样的问题，页面之间的切换以及空间的释放。如果不合理的设计的话，一上来就将所有的页面进行初始化，那将会占用许多不必要的内存空间，硬写之间的切换的话，界面一旦多起来，那切换逻辑将会绕来绕去，最终会写不下去。 所以合理设计一个页面管理函数或者说是对象将会非常重要。欢迎关注 ！！！！！！！基于上面三点就可以完成一个基本的页面管理对象了，是不是非常简单。 页面管理对象的实现，页面管理对象主要是为了方便页面之间的切换以及内存的释放(即删除没有加载在界面上页上的资源)。
lvgl官方设计器，edgeline的正式版本SquareLine 1.0，设计好界面后可以导出c或micropython代码
02-09
lvgl官方设计器，edgeline的正式版本SquareLine 1.0，设计好界面后可以导出c或micropython代码。
LVGL界面设计器V1.3
03-02
LVGL界面设计器是一款用户友好型图形用户界面开发工具，可通过开源LVGL图形库快速开发高品质的显示。GUI Guider的拖放编辑器可以轻松利用LVGL的众多特性，如小部件、动画和样式来创建GUI，而只需少量代码或根本无需任何代码。 单击按钮，您可以在模拟环境中运行应用或将其导出到目标项目。可以很轻松地将GUI Guider生成的代码添加到MCUXpresso IDE或IAR Embedded Workbench项目中，从而加速开发过程，并允许无缝地将嵌入式用户界面添加到应用中。 1. 支持拖放的所见即所得UI设计 2. 利用并搜索LVGL的各种小部件，轻松创建GUI应用 3. 自定义并配置小部件属性，可自定义您的设计 4. 轻松添加事件、动作和动画来增强您的应用 5. 导入图像和自定义字体的内置资源管理 6. 为MCUXpresso IDE和IAR Embedded Workbench项目生成应用代码 7. 集成的演示应用，可帮助您开始设计
LVGL中文输入法代码
01-17
LVGL中文输入法代码
lvgl使用旋转编码器(EC11)做为输入设备，使用单色OLED做为显示设备。
06-25
用的单色OLED屏显示，不得不说，使用单色屏幕的话，有些控件不能正常显示，需要自己额外设定一下，而且对于有动态变化的控件来说更是如此，比如按钮，在彩色屏幕下正常添加一个按钮按下时会有按下的动态效果，而在单色屏幕下就需要额外设置。还有开关等，可能都需要额外设置。对于只是起显示作用的控件来说影响不大，标签，图表，线条等。写了一个界面，其中包含两个按钮，使用编码器进行选择。
LVGL学习(3)：页面切换原理和页面管理实现
热门推荐
主要分享硬件、嵌入式软件部分知识
06-05 1万+
我们来分析一下这两种情况，比如页面1有一个列表框，有三个选项，每个选项对应进入一个页面。假设此时我们的焦点落在第二个选项上，然后点击进入页面2，我们要是想返回，我们是希望焦点还是保留在列表的第二个选项上的。基于这种情况来说，我们希望能够在保留页面1的同时(同时也保留了焦点)，创建页面2并加载。同时对于页面2来说，只是想用户选择的时候再加载，每次进入都处于初始状态，所以在从页面2返回页面1时，我们会希望删除页面2，再创建页面1并加载。
LVGL开发 | lv_lib_100ask之lvgl页面管理器(lv_100ask_page_manager)-页面管理简单方便
挨踢民工的博客
04-14 6895
lv_100ask_page_manager 是一个 lvgl 页面管理器。 **lv_100ask_page_manager** 特性： - 支持多级页面切换 - 跨页面切换 - 页面切换过渡动画 - 可以指定切换页面时是否删除当前页面(节省内存) - 自定义页面过渡动画(TODO) - 自定义页面返回按钮(TODO) - 页面选择器(TODO) - more todo...
LVGL学习笔记5 - Display, Screen和Layer
pq的博客
12-27 3183
目录1. Display2. Screen2.1 创建Screen2.2 加载Screen2.3 获取活动的Screen2.4 实例2.4.1 定义2个Screen全局变量2.4.2 初始化Screen2.4.3 循环更替3. Layer图层3.1 切换顺序3.2 顶层和系统层3.3 实例3.3.1 创建全局变量3.3.2 初始化3.3.3 循环更替处理在移植那里会有一个显示接口的移植，这部分其实对应的就是Display，可以翻译为显示器。在LVGL中，可以有多个Display，即物理上支持多个显示器。
LVGL 死机 内存泄漏
qq_29233185的博客
11-06 1559
LVGL
写一个LVGL页面管理器
05-13
LVGL（Light and Versatile Graphics Library）是一款开源的GUI库，用于嵌入式系统和智能设备的图形用户界面设计。在LVGL中，页面管理器（Page Manager）是用于管理不同页面或屏幕的组件，包括页面的创建，销毁，切换和更新等操作。下面是一个简单的LVGL页面管理器的示例代码： ``` #include "lvgl/lvgl.h" #define MAX_PAGES 5 // 定义页面ID typedef enum { PAGE_0, PAGE_1, PAGE_2, PAGE_3, PAGE_4 } page_id_t; // 定义页面结构体 typedef struct { page_id_t id; lv_obj_t *page; } page_t; // 定义页面数组 static page_t pages[MAX_PAGES] = {{PAGE_0, NULL}, {PAGE_1, NULL}, {PAGE_2, NULL}, {PAGE_3, NULL}, {PAGE_4, NULL}}; // 定义当前页面ID static page_id_t current_page_id = PAGE_0; // 初始化页面管理器 void page_mgr_init(void) { // 创建所有页面 for (int i = 0; i < MAX_PAGES; i++) { pages[i].page = lv_obj_create(NULL, NULL); lv_obj_set_size(pages[i].page, LV_HOR_RES, LV_VER_RES); lv_obj_set_hidden(pages[i].page, true); } // 显示当前页面 lv_obj_set_hidden(pages[current_page_id].page, false); } // 销毁所有页面 void page_mgr_deinit(void) { for (int i = 0; i < MAX_PAGES; i++) { if (pages[i].page != NULL) { lv_obj_del(pages[i].page); pages[i].page = NULL; } } } // 切换页面 void page_mgr_switch_page(page_id_t page_id) { if (page_id == current_page_id) { return; } // 隐藏当前页面 lv_obj_set_hidden(pages[current_page_id].page, true); // 显示新页面 lv_obj_set_hidden(pages[page_id].page, false); // 更新当前页面ID current_page_id = page_id; } // 获取当前页面ID page_id_t page_mgr_get_current_page_id(void) { return current_page_id; } ``` 在上面的代码中，我们首先定义了一个页面ID的枚举类型，其中包含了所有页面的ID。然后，我们定义了一个页面结构体，其中包含了页面的ID和LVGL对象指针。接着，我们定义了一个页面数组，其中包含了所有页面的结构体。在初始化页面管理器的函数中，我们创建了所有页面，并显示了当前页面。在销毁页面管理器的函数中，我们销毁了所有页面。在切换页面的函数中，我们隐藏了当前页面，并显示了新页面。最后，我们定义了一个获取当前页面ID的函数。 使用这个页面管理器的方法是，在每个页面中，使用LVGL对象来构建页面的UI界面。然后，在需要切换页面的地方，调用页面管理器的切换页面函数即可。 以上是一个简单的LVGL页面管理器的示例代码，仅供参考。在实际应用中，还需要根据具体的需求进行修改和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值