LVGL 集成与应用

void lvgl_main_task(void *priv)
{
    lvgl_suspend_flag = 0;
    int msg[8] = {0};
    int ret;
    lvgl_touch_timer_status = 0;
    char lvgl_task_pend_timeout_refr_flag = 0;
    u32 time_till_next;

    lvgl_v9_gui_init();

    //刷新第一帧不需要事件触发
    time_till_next = lv_timer_handler();
    if (time_till_next != 0xFFFFFFFF) {
        sys_hi_timeout_add(NULL, lvgl_timer_event_timeout, time_till_next);
    }

    while (1) {
        ret = os_taskq_pend_timeout(msg, ARRAY_SIZE(msg), portMAX_DELAY);
        if (ret != OS_TASKQ && ret != OS_TIMEOUT) {
            printf("lvgl_main_task os_taskq_pend err=%d %d\n", ret, msg[0]);
            continue;
        }

        lvgl_v9_main_task_hook();
        ...
    }
}

enum {
    UI_MSG_TOUCH = 1,        // 触摸事件（首次触摸或轮询使能）
    UI_MSG_ENCODER,          // 编码器旋钮事件（RDEC_UP/RDEC_DOWN）
    UI_MSG_KEY,              // 普通按键事件
    UI_MSG_TIMER_TIMEOUT,    // LVGL 定时器到期（由 sys_hi_timeout 触发）
    UI_MSG_SUSPEND,          // 挂起 UI（进入低功耗）
    UI_MSG_RESUME,           // 恢复 UI（全屏刷新）
    UI_MSG_RPC_FUNC,         // 跨线程函数调用（RPC 通道）
};

enum LVGL_Q_USER_TYPE {
    LVGL_Q_USER_TYPE_TOUCH = 0x10000,//从这个立即数开始是为了删消息池使用,不可更改
    LVGL_Q_USER_TYPE_KEY = 0x20000,
};

int lvgl_key_event_handler(struct sys_event *event)
{
    if (lvgl_suspend_flag) {
        return 0;   // UI 挂起时丢弃按键
    }

    struct key_event *key = (struct key_event *)event->payload;
    if (key->key_intercept) {
        return 0;   // 被其它模块截获的按键不再投递
    }
    if ((key->action == KEY_EVENT_UP) && (key->value != s_last_key_value)) {
        puts("lvgl_key_event_handler post failed 1");
        return -EINVAL;
    }

    if (key_event_drop_timeout_id) {
        puts("lvgl_key_event_handler post failed 2");
        return -EINVAL;
    }

    if (lvgl_key_msg_remain_cnt > 2) {
        puts("lvgl_key_event_handler post failed 3");
        goto  _retry;
    }
    int msg[2 + sizeof(struct key_event) / 4];
    msg[0] = UI_MSG_KEY;
    memcpy(&msg[1], key, sizeof(struct key_event));
    if (os_taskq_post_type(LVGL_TASK_NAME, Q_USER, ARRAY_SIZE(msg), msg)) {
        puts("lvgl_key_event_handler post failed 4");
        goto  _retry;
    } else {
        s_last_key_value = key->value;
        ++lvgl_key_msg_remain_cnt;
    }

    return -EINVAL;

_retry:
    //由于LVGL不可丢失按键抬起消息, 判断丢失的消息是按键抬起消息才做重发动作
    if (key->action == KEY_EVENT_UP && key->value == s_last_key_value) {
        memcpy(&s_drop_key_event, key, sizeof(struct key_event));
        key_event_drop_timeout_id = sys_timeout_add_to_task(LVGL_TASK_NAME, NULL, key_event_drop_timeout_handler, 30);
    }

    return -EINVAL;
}

/*
 * down事件不发给UI,等到按键抬起后up事件拆分为2次事件发给UI
 * 这样做的好处是能区分出短按和长按,例如按键短按和长按分别有不同UI功能时
 * */
int lvgl_key_event_handler_2(struct sys_event *event)

int lcd_touch_interrupt_event(const char *tp_task_name, u16 x, u16 y, u8 status)
{
    int err;
    if (lvgl_suspend_flag) {
        return 0;
    }

    if (status) {
        int msg[6];
        //检测到触摸,创建定时器启用轮询
        if (!lvgl_touch_timer_status) {//这个标志是用来防止多次发消息
            msg[0] = UI_MSG_TOUCH;
            msg[1] = (int)x;
            msg[2] = (int)y;
            msg[3] = (int)status;
            err = os_taskq_post_type(LVGL_TASK_NAME, Q_USER, ARRAY_SIZE(msg), msg);
            if (err) {
                printf("lvgl touch msg drop2 err = %d\n", err);
                return err;
            }
            lvgl_touch_timer_status = 1;
        } else {
            //确保定时器创建成功
            if (lv_indev_set_touch_timer_check() == false) {
                msg[0] = UI_MSG_TOUCH;
                ...
            }
        }
        return 0;
    }
    return 0;
}

static void lvgl_timer_event_timeout(void *p)
{
    int err;
    int msg[2];
    msg[0] = UI_MSG_TIMER_TIMEOUT;
    lvgl_timeout_id = 0;
    err =  task_queue_post_event(LVGL_TASK_NAME,  msg, ARRAY_SIZE(msg));
    if (err) {
        printf("lvgl_timer_event_timeout post_ui_msg err=%d\n", err);
    } else {
        lvgl_timerout_msg_remain_flag = 1;
    }
}

int lvgl_rpc_post_func(void (*rpc_func)(void *, ...), int argc, ...)
{
    int err;

    if (lvgl_suspend_flag) {
        printf("lvgl_rpc_post suspended \n");
        return -1;
    }

    int msg[8];

    msg[0] = UI_MSG_RPC_FUNC;
    msg[1] = argc;
    msg[2] = (int)rpc_func;

    ASSERT(argc <= ARRAY_SIZE(msg) - 3, "%s argc too long!\n", __FUNCTION__);

    va_list argptr;
    va_start(argptr, argc);
    for (int i = 0; i < argc; i++) {
        msg[i + 3] = va_arg(argptr, int);
    }
    va_end(argptr);

_RETRY:
    err = os_taskq_post_type(LVGL_TASK_NAME, Q_USER, ARRAY_SIZE(msg), msg);
    if (err) {
        printf("lvgl_rpc_post_func err=%d\n", err);
        msleep(20);
        goto _RETRY;
    }
    return 0;
}

void _lvgl_ui_task_suspend_resume(uint8_t state, void *cb)
{
    OS_SEM sem_wait;
    int err;
    int msg[4];
    u8 is_need_wait = 1;
    msg[0] = state ? UI_MSG_RESUME : UI_MSG_SUSPEND;
    msg[1] = (int)cb;
    msg[2] = state;
    msg[3] = (int)&sem_wait;

    if (!strcmp(os_current_task(), LVGL_TASK_NAME)) {
        //当前如果不在lvgl线程则需要等待
        is_need_wait = 0;
        msg[3] = 0;
    }

    os_sem_create(&sem_wait, 0);
    err =  os_taskq_post_type(LVGL_TASK_NAME, Q_MSG, ARRAY_SIZE(msg), msg);
    if (err) {
        printf("lvgl_ui_start_stop post err=%d\n", err);
    } else {
        if (is_need_wait) {
            err = os_sem_pend(&sem_wait, 300);
            ASSERT(err != OS_TIMEOUT, "%s %s no response\n", __FUNCTION__, state ? "RESUME" : "SUSPEND");
        }
    }
    os_sem_del(&sem_wait, OS_DEL_ALWAYS);
}

void lvgl_ui_suspend(void)      { _lvgl_ui_task_suspend_resume(0, _lv_ui_suspend_resume_cb); }
void lvgl_ui_resume(void)       { _lvgl_ui_task_suspend_resume(1, _lv_ui_suspend_resume_cb); }
u8   lvgl_ui_is_suspended(void) { return lvgl_suspend_flag; }

void lvgl_v9_gui_init(void)
{
    puts("lvgl_v9_gui_init \n\n");

    lv_init();
    lv_port_disp_init();
    lv_port_indev_init();
    lv_port_fs_init();
    lv_tick_set_cb(&timer_get_ms);

#if LV_USE_MONKEY != 0
    /*Create pointer monkey test*/
    lv_monkey_config_t monkey_pointer_config;
    monkey_pointer_config.type = LV_INDEV_TYPE_POINTER;
    monkey_pointer_config.period_range.min = 20;
    monkey_pointer_config.period_range.max = 20;
    lv_monkey_set_enable(lv_monkey_create(&monkey_pointer_config), true);

    /*Create keypad monkey test*/
    lv_monkey_config_t monkey_keypad_config;
    monkey_keypad_config.type = LV_INDEV_TYPE_KEYPAD;
    monkey_keypad_config.period_range.min = 20;
    monkey_keypad_config.period_range.max = 20;
    lv_monkey_set_enable(lv_monkey_create(&monkey_keypad_config), true);

    /*Create encoder monkey test*/
    lv_monkey_config_t monkey_encode_config;
    monkey_encode_config.type = LV_INDEV_TYPE_ENCODER;
    monkey_encode_config.period_range.min = 20;
    monkey_encode_config.period_range.max = 20;
    monkey_encode_config.input_range.min = -5;
    monkey_encode_config.input_range.max = 5;
    lv_monkey_set_enable(lv_monkey_create(&monkey_encode_config), true);
#endif

    /*lv_demo_benchmark();*/
    lv_demo_widgets();
    /*lv_demo_keypad_encoder();*/
}

static void create_my_label(void)
{
    lv_obj_t *scr = lv_screen_active();
    lv_obj_t *overlay;
    lv_obj_t *label;

    /* The root screen stays at the compose color key so only the real widgets cover the camera. */
    lv_obj_set_style_bg_color(scr, lv_color_hex(0x55aaa5), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, LV_PART_MAIN);
    lv_obj_set_style_border_opa(scr, LV_OPA_TRANSP, LV_PART_MAIN);
    lv_obj_set_style_outline_opa(scr, LV_OPA_TRANSP, LV_PART_MAIN);
    lv_obj_set_style_shadow_opa(scr, LV_OPA_TRANSP, LV_PART_MAIN);

    overlay = lv_obj_create(scr);
    lv_obj_remove_style_all(overlay);
    lv_obj_set_size(overlay, 280, 64);
    lv_obj_align(overlay, LV_ALIGN_CENTER, 0, 0);
    lv_obj_set_style_bg_color(overlay, lv_color_hex(0x000000), 0);
    lv_obj_set_style_bg_opa(overlay, LV_OPA_80, 0);
    lv_obj_set_style_border_color(overlay, lv_color_hex(0xFFFFFF), 0);
    lv_obj_set_style_border_width(overlay, 2, 0);
    lv_obj_set_style_radius(overlay, 8, 0);
    lv_obj_clear_flag(overlay, LV_OBJ_FLAG_SCROLLABLE);

    label = lv_label_create(overlay);
    lv_label_set_text(label, "UI refresh test");
    lv_obj_set_size(label, 240, LV_SIZE_CONTENT);
    lv_obj_center(label);
    lv_obj_set_style_text_align(label, LV_TEXT_ALIGN_CENTER, 0);
    lv_obj_set_style_text_font(label, &lv_font_montserrat_20, 0);
    lv_obj_set_style_text_color(label, lv_color_hex(0xFFFFFF), 0);

    lv_timer_create(label_update_timer_cb, 1000, label);
    update_test_label(label);
}

static void label_update_timer_cb(lv_timer_t *timer)
{
    lv_obj_t *label = timer ? lv_timer_get_user_data(timer) : NULL;
    if (label == NULL) {
        return;
    }
    update_test_label(label);
}

static void update_test_label(lv_obj_t *label)
{
    static uint32_t refresh_cnt;

    refresh_cnt++;
    lv_label_set_text_fmt(label, "UI refresh ok\ncount: %04" LV_PRIu32, refresh_cnt);
}

static void lv_example_img_bin(void)
{
    LV_IMAGE_DECLARE(img_benchmark_cogwheel_argb);
    static lv_style_t style_common;

    lv_style_reset(&style_common);

    lv_obj_t *img = lv_img_create(lv_scr_act());
    lv_obj_t *label = lv_label_create(lv_scr_act());
    lv_obj_remove_style_all(img);
    lv_obj_add_style(img, &style_common, 0);

    //Img
    lv_obj_set_pos(img, 330, 189);
    //C数组
    /* lv_img_set_src(img, &img_benchmark_cogwheel_argb); */
    //bin文件
    lv_img_set_src(img, "mnt/sdfile/EXT_RESERVED/uipackres/ui/logoargb.bin");

    //Font
    /* lv_font_t *font_bin = lv_font_load_bin("mnt/sdfile/EXT_RESERVED/uipackres/ui/font1.bin"); //不压缩字体 */
    lv_font_t *font_bin = lv_font_load_bin("mnt/sdfile/EXT_RESERVED/uipackres/ui/font1.rle");//压缩字体
    lv_obj_set_style_text_font(label, font_bin, LV_PART_MAIN);
    /* lv_obj_set_style_text_font(label,&lv_font_montserrat_24, LV_PART_MAIN);//C数组 */

    lv_label_set_text(label, "123");

    lv_obj_set_pos(label, 100, 100);
}