RT-Thread-RT-Thread Studio使用记录（十）LittlevGL2RTT 贪吃蛇RT-Thread问答社区

RT-Thread Studio使用记录（十）LittlevGL2RTT 贪吃蛇

发布于 2021-01-31 23:49:25 浏览：2371 订阅该版

[RT-Thread Studio使用记录（一）点亮led](https://club.rt-thread.org/ask/article/2519.html)
[RT-Thread Studio使用记录（二）pwm呼吸灯](https://club.rt-thread.org/ask/article/2520.html)
[RT-Thread Studio使用记录（三）flash挂载文件系统](https://club.rt-thread.org/ask/article/2521.html)
[RT-Thread Studio使用记录（四）SD-Card 挂载文件系统](https://club.rt-thread.org/ask/article/2526.html)
[RT-Thread Studio使用记录（五）USB 虚拟串口](https://club.rt-thread.org/ask/article/2524.html)
[RT-Thread Studio使用记录（六）ESP8266网络设备](https://club.rt-thread.org/ask/article/2527.html)
[RT-Thread Studio使用记录（七）STemWin](https://club.rt-thread.org/ask/article/2529.html)
[RT-Thread Studio使用记录（八）LittlevGL2RTT](https://club.rt-thread.org/ask/article/2530.html)
[RT-Thread Studio使用记录（九）LittlevGL2RTT触摸屏](https://club.rt-thread.org/ask/article/2531.html)
[RT-Thread Studio使用记录（十）LittlevGL2RTT 贪吃蛇](https://club.rt-thread.org/ask/article/2534.html)
[RT-Thread Studio使用记录（十一）LittlevGL2RTT 贪吃蛇+俄罗斯方块](https://club.rt-thread.org/ask/article/2544.html)

本章使用 RT-Thread 的 LittlevGL2RTT 软件包，使用前两节完成的 LCD 的驱动，设计完成一个贪吃蛇小游戏。

完成效果：[RT-Thread 使用 LittlevGL 制作贪吃蛇小游戏](https://www.bilibili.com/video/BV16z4y1m7E3/)

参考：1、[贪吃蛇游戏C语言源代码学习](https://www.cnblogs.com/jacklu/p/5214692.html)
2、[lvgl官方](https://docs.lvgl.io/v7/en/html/widgets/index.html)
3、[正点原子 lvgl 教程](http://www.openedv.com/forum.php?mod=viewthread&tid=311917&extra=page%3D1%26filter%3Ddigest%26digest%3D1)
    正点原子的教程版本较低，littleVGL 迭代快导致部分教程在新版本下无法使用，所以重点参考 littleVGL 官方文档。

1、 开启 beep 软件包，在运行过程中给出蜂鸣音。位置 ：RT-Thread online packages --> peripheral libraries and drivers --> beep

![rt-settings.png](https://oss-club.rt-thread.org/uploads/20210131/4c56add867cd26961ec514faa9b32bb2.png)

2、 取消 littlevgl2rtt_demo 程序的运行，在 littlevgl2rtt_demo.c 中注释掉 ”INIT_APP_EXPORT(rt_lvgl_demo_init);“ 即可。

![lvgl-demo.png](https://oss-club.rt-thread.org/uploads/20210131/66150cc094db379c483c39e5ce0b414c.png)

3、 在 applications 文件夹新建 snake.c 和 snake.h 两个文件，内容如下：

```
#ifndef __SNAKE_H__
#define __SNAKE_H__

#ifdef  __cplusplus
extern  "C"{
#endif // __cplusplus

#define     USING_RT_LIST_SNAKE

/**
 *  INCLUDES
 */
#ifdef  LV_CONF_INCLUDE_SIMPLE
#include "lvgl.h"
#include "lv_ex_conf.h"
#else
#include "../lvgl/lvgl.h"
#include "../lv_conf.h"
#endif // LV_CONF_INCLUDE_SIMPLE

#include <rtthread.h>
#include <rtdevice.h>

typedef struct SNAKE_RT_LIST
{
    int x;
    int y;
    rt_list_t body_node;
}snake_rt_list;

void snakemove(void);
void rungame(void);
void snake_start(void);

#ifdef __cplusplus
}/* extern "C" */
#endif // __cplusplus

#endif // __SNAKE_H__

```

```
#include "snake.h"
#include "stdlib.h"
#include "time.h"
#include <unistd.h>
#include <stdio.h>
#include "beep.h"

#ifdef USING_RT_LIST_SNAKE

#define GAME_STATUS_RUNNING     1
#define GAME_STATUS_STOP        0

#define SNAKE_UP    1
#define SNAKE_DOWN  2
#define SNAKE_LEFT  3
#define SNAKE_RIGHT 4

#define SNAKE_SPEED 5
#define SNAKE_SPEED_MAX 10

#define BORDER_X_START  10
#define BORDER_X_END    210
#define BORDER_Y_START  1
#define BORDER_Y_END    271
#define BORDER_LINE_WIDTH   2
#define BORDER_LINE_COLOR   LV_COLOR_RED

#define SNAKE_CANVAS_WIDTH      (BORDER_X_END-BORDER_X_START)   //202//180 //画布 2 的宽度
#define SNAKE_CANVAS_HEIGHT     (BORDER_Y_END-BORDER_Y_START)   //272//240 //画布 2 的高度

#define SNAKE_BODY_WIDTH    5
#define SNAKE_BODY_HEIGHT   5
#define SNAKE_BODY_SIZE     20
#define SNAKE_BODY_SIZE_SMALL   5
#define SNAKE_BODY_SIZE_MEDIUM  10
#define SNAKE_BODY_SIZE_LARGE   20

static uint8_t snake_speed = 1;
static uint8_t snake_body_size = SNAKE_BODY_SIZE_MEDIUM;

static uint8_t beep_enable = false;

#define SNAKE_START_X   0
#define SNAKE_START_Y   ((SNAKE_CANVAS_HEIGHT/SNAKE_BODY_SIZE-1)*SNAKE_BODY_SIZE)

#define COLOR_DRAW_WHITE    0
#define COLOR_DRAW_BLACK    5627

const lv_point_t border_line_points[] = {{BORDER_X_START, BORDER_Y_START},      //边界点
                                            {BORDER_X_START, BORDER_Y_END},
                                            {BORDER_X_END, BORDER_Y_END},
                                            {BORDER_X_END, BORDER_Y_START},
                                            {BORDER_X_START, BORDER_Y_START}};
const char speed_roller_options[] = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10";
const char size_roller_options[] = "small\nmedium\nlarge";

static lv_color_t snake_canvas_cbuf[LV_CANVAS_BUF_SIZE_ALPHA_1BIT(SNAKE_CANVAS_WIDTH, SNAKE_CANVAS_HEIGHT)];
lv_obj_t * snake_canvas;        //画布
lv_draw_rect_dsc_t snake_rect_dsc;
lv_obj_t *up_button, *down_button, *left_button, *right_button, *start_button, *stop_button;
lv_obj_t *beep_button;
lv_obj_t *speed_roller, *size_roller;       //速度，大小选项

lv_obj_t *beep_button_label;
lv_obj_t *info_label;       //提示
lv_obj_t *score_label;      //分数

rt_list_t snake_list;
static rt_list_t *list_node_head;
static snake_rt_list *head;     //头
snake_rt_list *food;            //食物

static lv_obj_t* scr;
int score = 0, add = 10;        //总分数， 单个食物分数
int status;                     //方向
int endGamestatus = 0;          //游戏停止原因

static int game_status = GAME_STATUS_STOP;     //游戏状态，  1，运行；0，停止

void creatmap();
void initsnake();
int biteself();
void creatfood();
int cantcrosswall();
void snakemove();
void snake_pause();
void rungame();
void initgame();
void endgame(void);
void gamestart();

static void btn_event_cb(lv_obj_t *obj, lv_event_t event)
{
    if(event == LV_EVENT_PRESSED)
    {
        if((obj == up_button) && (status != SNAKE_DOWN))    //上
        {
            status = SNAKE_UP;
        }
        if((obj == down_button) && (status != SNAKE_UP))    //下
        {
            status = SNAKE_DOWN;
        }
        if((obj == left_button) && (status != SNAKE_RIGHT))    //左
        {
            status = SNAKE_LEFT;
        }
        if((obj == right_button) && (status != SNAKE_LEFT))    //右
        {
            status = SNAKE_RIGHT;
        }
        if((obj == start_button) && (game_status != GAME_STATUS_RUNNING))    //开始
        {
            game_status = GAME_STATUS_RUNNING;
        }
        if((obj == stop_button) && (game_status != GAME_STATUS_STOP))    //停止
        {
            endGamestatus = 3;
//            endgame();
        }
        if(obj == beep_button)
        {
            lv_btn_state_t state = lv_btn_get_state(beep_button);

if(state == LV_BTN_STATE_PRESSED)
            {
                lv_label_set_text(beep_button_label, LV_SYMBOL_VOLUME_MAX);
                beep_enable = true;
//                rt_kprintf("beep_enabel = %d\r\n", beep_enable);
            }
            else
            {
                lv_label_set_text(beep_button_label, LV_SYMBOL_MUTE);
                beep_enable = true;
                beep(1, 100, 50, 0);
//                rt_kprintf("beep_enabel = %d\r\n", beep_enable);
            }
        }
    }
}

static void roller_event_cb(lv_obj_t *obj, lv_event_t event)
{
    uint16_t selected_number;
    if(event == LV_EVENT_VALUE_CHANGED)
    {
        selected_number = lv_roller_get_selected(obj);
        if (obj == speed_roller)            //速度
        {
            snake_speed = selected_number;
            if(snake_speed >= SNAKE_SPEED_MAX)
            {
                snake_speed = SNAKE_SPEED_MAX - 1;
            }
        }
        else if(obj == size_roller && game_status == GAME_STATUS_STOP) //大小
        {
            switch(selected_number)
            {
                case 0:
                    snake_body_size = SNAKE_BODY_SIZE_SMALL;
                    break;
                case 1:
                    snake_body_size = SNAKE_BODY_SIZE_MEDIUM;
                    break;
                case 2:
                    snake_body_size = SNAKE_BODY_SIZE_LARGE;
                    break;
                default:
                    break;
            }
        }
    }
}

void creatmap()     //画初始面板
{
    lv_color_t color0;
    lv_obj_t *border_line;
    static lv_style_t style_border_line;

lv_style_init(&style_border_line);      //外框线style
    lv_style_set_line_width(&style_border_line, LV_STATE_DEFAULT, BORDER_LINE_WIDTH);
    lv_style_set_line_color(&style_border_line, LV_STATE_DEFAULT, BORDER_LINE_COLOR);
    lv_style_set_line_rounded(&style_border_line, LV_STATE_DEFAULT, true);

scr = lv_disp_get_scr_act(NULL);

border_line = lv_line_create(scr, NULL);    //外框线
    lv_line_set_points(border_line, border_line_points, sizeof(border_line_points)/sizeof(border_line_points[0]));
    lv_obj_add_style(border_line, LV_LINE_PART_MAIN, &style_border_line);

info_label = lv_label_create(scr, NULL);    //  提示
    lv_obj_set_pos(info_label, 295, 10);
    lv_obj_set_width(info_label, 100);
    lv_label_set_text(info_label, "");
    score_label = lv_label_create(scr, NULL);   //分数
    lv_obj_set_pos(score_label, 355, 60);
    lv_label_set_text(score_label, "");

snake_canvas = lv_canvas_create(lv_scr_act(), NULL);    //画布
    lv_canvas_set_buffer(snake_canvas, snake_canvas_cbuf, SNAKE_CANVAS_WIDTH, SNAKE_CANVAS_HEIGHT, LV_IMG_CF_ALPHA_1BIT);

color0.full = COLOR_DRAW_WHITE;//指向调色板中的第一种颜色
    lv_obj_align(snake_canvas, NULL, LV_ALIGN_IN_LEFT_MID, 10, 0);
    lv_canvas_fill_bg(snake_canvas, color0, LV_OPA_COVER);

up_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(up_button, btn_event_cb);
    lv_obj_set_size(up_button, 50, 50);
    lv_obj_set_pos(up_button, 380, 100);

down_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(down_button, btn_event_cb);
    lv_obj_set_size(down_button, 50, 50);
    lv_obj_align(down_button, up_button, LV_ALIGN_OUT_BOTTOM_MID, 0, 50);

left_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(left_button, btn_event_cb);
    lv_obj_set_size(left_button, 50, 50);
    lv_obj_align(left_button, up_button, LV_ALIGN_OUT_BOTTOM_LEFT, -50, 0);

right_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(right_button, btn_event_cb);
    lv_obj_set_size(right_button, 50, 50);
    lv_obj_align(right_button, up_button, LV_ALIGN_OUT_BOTTOM_RIGHT, 50, 0);

start_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(start_button, btn_event_cb);
    lv_obj_set_size(start_button, 50, 50);
    lv_obj_align(start_button, left_button, LV_ALIGN_OUT_BOTTOM_LEFT, -100, 0);

stop_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(stop_button, btn_event_cb);
    lv_obj_set_size(stop_button, 50, 50);
    lv_obj_align(stop_button, left_button, LV_ALIGN_OUT_TOP_LEFT, -100, 30);

beep_button = lv_btn_create(scr, NULL);
    lv_obj_set_event_cb(beep_button, btn_event_cb);
    lv_obj_set_size(beep_button, 30, 30);
    lv_obj_align(beep_button, left_button, LV_ALIGN_OUT_BOTTOM_LEFT, -30, 30);
    lv_btn_set_checkable(beep_button, true);

lv_obj_t* up_button_label = lv_label_create(up_button, NULL);
    lv_obj_t* down_button_label = lv_label_create(down_button, NULL);
    lv_obj_t* left_button_label = lv_label_create(left_button, NULL);
    lv_obj_t* right_button_label = lv_label_create(right_button, NULL);
    lv_obj_t* start_button_label = lv_label_create(start_button, NULL);
    lv_obj_t* stop_button_label = lv_label_create(stop_button, NULL);
    beep_button_label = lv_label_create(beep_button, NULL);

lv_label_set_text(up_button_label, "U");
    lv_label_set_text(down_button_label, "D");
    lv_label_set_text(left_button_label, "L");
    lv_label_set_text(right_button_label, "R");
    lv_label_set_text(start_button_label, "start");
    lv_label_set_text(stop_button_label, "stop");
    lv_label_set_text(beep_button_label, LV_SYMBOL_MUTE);

speed_roller = lv_roller_create(scr, NULL);     //速度选项
    lv_roller_set_options(speed_roller, speed_roller_options, LV_ROLLER_MODE_INIFINITE);
    lv_roller_set_fix_width(speed_roller, 80);
    lv_roller_set_visible_row_count(speed_roller, 1);
    lv_roller_set_selected(speed_roller, 0, LV_ANIM_OFF);
    lv_obj_align(speed_roller, stop_button, LV_ALIGN_OUT_TOP_MID, 0, -30);
    lv_obj_set_event_cb(speed_roller, roller_event_cb);

size_roller = lv_roller_create(scr, NULL);      //尺寸选项
    lv_roller_set_options(size_roller, size_roller_options, LV_ROLLER_MODE_INIFINITE);
    lv_roller_set_fix_width(size_roller, 80);
    lv_roller_set_visible_row_count(size_roller, 1);
    lv_roller_set_selected(size_roller, 1, LV_ANIM_OFF);
    lv_obj_align(size_roller, speed_roller, LV_ALIGN_OUT_TOP_MID, 0, -10);
    lv_obj_set_event_cb(size_roller, roller_event_cb);
}

void initsnake()    //初始小蛇
{
    snake_rt_list *tail;
    int i;
    lv_color_t color0;
    uint16_t selected_number;

lv_label_set_text(info_label, "");      //清空提示信息

rt_list_init(&snake_list);
    list_node_head = &snake_list;

status = SNAKE_UP;              //默认向上

selected_number = lv_roller_get_selected(speed_roller);     //速度初始化
    snake_speed = selected_number;
    if(snake_speed >= SNAKE_SPEED_MAX)
    {
        snake_speed = SNAKE_SPEED_MAX - 1;
    }
    selected_number = lv_roller_get_selected(size_roller);     //尺寸初始化
    switch(selected_number)
    {
       case 0:
           snake_body_size = SNAKE_BODY_SIZE_SMALL;
           break;
       case 1:
           snake_body_size = SNAKE_BODY_SIZE_MEDIUM;
           break;
       case 2:
           snake_body_size = SNAKE_BODY_SIZE_LARGE;
           break;
       default:
           break;
    }

color0.full = COLOR_DRAW_WHITE;//指向调色板中的第一种颜色
    lv_canvas_fill_bg(snake_canvas, color0, LV_OPA_COVER);

lv_draw_rect_dsc_init(&snake_rect_dsc);
    snake_rect_dsc.bg_opa = LV_OPA_100;
    snake_rect_dsc.bg_color = color0;

tail = (snake_rt_list*)rt_malloc(sizeof(snake_rt_list));
    tail->x = SNAKE_START_X;
    tail->y = ((SNAKE_CANVAS_HEIGHT/snake_body_size-1)*snake_body_size);
    rt_list_insert_after(&snake_list, &tail->body_node);

for(i=1;i<=4;i++)
    {
        head = (snake_rt_list*)rt_malloc(sizeof(snake_rt_list));
        head->x = SNAKE_START_X + snake_body_size * i;
        head->y = ((SNAKE_CANVAS_HEIGHT/snake_body_size-1)*snake_body_size);//SNAKE_START_Y;//SNAKE_CANVAS_HEIGHT - 30;
        rt_list_insert_after(&snake_list, &head->body_node);
    }
    rt_list_for_each_entry(tail, &snake_list, body_node)    //遍历链表
    {
        color0.full = COLOR_DRAW_WHITE;//指向调色板中的第一种颜色
        snake_rect_dsc.bg_color = color0;
        lv_canvas_draw_rect(snake_canvas, tail->x, tail->y, snake_body_size, snake_body_size, &snake_rect_dsc);
    }

if(beep_enable == true)
    {
        beep(2, 100, 50, 0);        //开始提示音，两声
    }
}

//撞自己返回1，否则返回0
int biteself()  //
{
    snake_rt_list *self;
    rt_uint16_t i = 0;

rt_list_for_each_entry(self, &snake_list, body_node)    //遍历链表
    {
        i++;
        if(i <= 3)  //前3个不会碰到自己
        {
            continue;
        }
        if((self->x == head->x) && (self->y == head->y))
        {
            return 1;
        }
    }
    return 0;
}

void creatfood()    //创造食物
{
    snake_rt_list *food_1;
    snake_rt_list *tail;
    rt_uint8_t result = 0;

srand((unsigned)time(NULL));    //以时间做随机种子，不会导致每次随机数都一样
    food_1 = (snake_rt_list *)rt_malloc(sizeof(snake_rt_list));

do
    {
        do
        {
            food_1->x = rand() % (SNAKE_CANVAS_WIDTH-snake_body_size);    //随机 x
        } while (((food_1->x) % snake_body_size) != 0); //宽度间隔对齐

do
        {
            food_1->y = rand() % (SNAKE_CANVAS_HEIGHT-snake_body_size);   //随机y
        } while (((food_1->y) % snake_body_size) != 0); //高度间隔对齐

rt_list_for_each_entry(tail, &snake_list, body_node)    //遍历链表
        {
//            rt_kprintf("tail->x:%d, tail->y:%d\r\n", tail->x, tail->y);
//            rt_kprintf("food->x:%d, food->y:%d\r\n", food->x, food->y);
            if(tail->x == food_1->x && tail->y == food_1->y)    //与蛇身重叠
            {
                result = 0;
                break;
            }
            else
            {
                result = 1;
            }
        }
    } while (result == 0);

food = food_1;

lv_color_t color0;
    color0.full = COLOR_DRAW_WHITE;//指向调色板中的第一种颜色
    snake_rect_dsc.bg_color = color0;
    lv_canvas_draw_rect(snake_canvas, food->x, food->y, snake_body_size, snake_body_size, &snake_rect_dsc);
    rt_kprintf("food->x:%d, food->y:%d\r\n", food->x, food->y);
}

// 撞墙返回1，否则返回0
int cantcrosswall()    //
{
    if(head->x < 0 || head->x > SNAKE_CANVAS_WIDTH-snake_body_size || head->y < 0 || head->y > SNAKE_CANVAS_HEIGHT-snake_body_size)
    {
        return 1;
    }
    return 0;
}

void snakemove()
{
    snake_rt_list *nexthead;
    snake_rt_list *tail;
    lv_color_t color0;

nexthead = (snake_rt_list*)rt_malloc(sizeof(snake_rt_list));

if(status == SNAKE_UP)
    {
        nexthead->x = head->x;
        nexthead->y = head->y - snake_body_size;
    }
    else if(status == SNAKE_DOWN)
    {
        nexthead->x = head->x;
        nexthead->y = head->y + snake_body_size;
    }
    else if(status == SNAKE_LEFT)
    {
        nexthead->x = head->x - snake_body_size;
        nexthead->y = head->y;
    }
    else if(status == SNAKE_RIGHT)
    {
        nexthead->x = head->x + snake_body_size;
        nexthead->y = head->y;
    }

rt_list_insert_after(&snake_list, &nexthead->body_node);    //插入新位置到蛇头
    head = nexthead;

if(nexthead->x == food->x && nexthead->y == food->y)    //迟到食物
    {
        score = score + add;
        rt_free(food);
        creatfood();
        if(beep_enable == true)
        {
            beep(1, 100, 50, 0);        //吃到食物提示音，一声
        }
    }
    else    //没吃到食物
    {
        tail = rt_list_entry(snake_list.next, snake_rt_list, body_node);        //画新头
        color0.full = COLOR_DRAW_WHITE;//指向调色板中的第一种颜色
        snake_rect_dsc.bg_color = color0;
        lv_canvas_draw_rect(snake_canvas, tail->x, tail->y, snake_body_size, snake_body_size, &snake_rect_dsc);
//        rt_kprintf("tail->x:%d, tail->y:%d\r\n", tail->x, tail->y);

tail = rt_list_entry(snake_list.prev, snake_rt_list, body_node);        //擦尾巴
        color0.full = COLOR_DRAW_BLACK;//指向调色板中的第一种颜色
        snake_rect_dsc.bg_color = color0;
        lv_canvas_draw_rect(snake_canvas, tail->x, tail->y, snake_body_size, snake_body_size, &snake_rect_dsc);
//        rt_kprintf("tail->x:%d, tail->y:%d\r\n", tail->x, tail->y);
        rt_list_remove(&tail->body_node);   //释放空间
        rt_free(tail);
    }

if(biteself() == 1)     //是否咬到自己
    {
        endGamestatus = 2;
//        endgame();
    }
    if(cantcrosswall() == 1)    //是否撞墙
    {
        endGamestatus = 1;
//        endgame();
    }
}

void rungame()  //
{
    char str[100];

while(1)
    {
        rt_thread_delay(50 * (SNAKE_SPEED_MAX - snake_speed));  //移动速度

snakemove();
        if(endGamestatus != 0)
        {
            break;
        }

sprintf(str, "score: %d ", score);
        lv_label_set_text(score_label, str);
    }
}

void initgame(void)
{
    endGamestatus = 0;
    score = 0;
}

void endgame(void)
{
    snake_rt_list *tail;

switch(endGamestatus)
    {
        case 1:
            lv_label_set_text(info_label, "sorry, can't cross the wall.\n             game over.");
            break;
        case 2:
            lv_label_set_text(info_label, "sorry, can't bit your self.\n           game over");
            break;
        case 3:
            lv_label_set_text(info_label, "                game over");
            break;
        default:
            break;
    }

game_status = GAME_STATUS_STOP;

if(beep_enable == true)
    {
        beep(3, 100, 50, 0);        //停止提示音，三声
    }
}

void gamestart()    //
{
    initgame();
//    creatmap();
    initsnake();
    creatfood();
}

void snake_start()
{
    creatmap();
    for(;;)
    {
        if(game_status == GAME_STATUS_RUNNING)//开始
        {
            gamestart();
            rungame();

if(endGamestatus != 0)
            {
                endgame();
            }
        }

rt_thread_delay(RT_TICK_PER_SECOND / 10);
    }
}
//INIT_APP_EXPORT(snake_start);

#endif

```

4、 在 applications 文件夹新建文件 lvgl_app.c 。内容如下：

```
/*
 * Copyright (c) 2006-2020, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2021-01-06     mgcheng       the first version
 */

#include "littlevgl2rtt.h"
#include "lvgl.h"

#include <rtthread.h>

extern void snake_start(void);

static void lvgl_app_entry(void *parameter)
{
    snake_start();
}

int rt_lvgl_app_init(void)
{
    rt_err_t ret = RT_EOK;
    rt_thread_t thread = RT_NULL;

/* init littlevGL */
    ret = littlevgl2rtt_init("lcd");
    if(ret != RT_EOK)
    {
        return ret;
    }

/* littleGL demo gui thread */
    thread = rt_thread_create("lvgl_app", lvgl_app_entry, RT_NULL, 10*1024, 7, 10);
    if(thread == RT_NULL)
    {
        return RT_ERROR;
    }
    rt_thread_startup(thread);

return RT_EOK;
}
//INIT_APP_EXPORT(rt_lvgl_app_init);

```

5、 在 main 函数中， xpt2046_init() 后调用 rt_snake_thread_init()。

![main.png](https://oss-club.rt-thread.org/uploads/20210201/b250bf09e418f134ded5a998d000a333.png)

6、 编译运行。

![效果.png](https://oss-club.rt-thread.org/uploads/20210131/0ccba95e98a9780540804826625ba180.png)