[STM32H7] STM32H745I-DISCO试用】移植LVGL

/**

 * [url=home.php?mod=space&uid=288409]@file[/url] lv_port_disp_templ.c

 *

 */



/*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/

#if 1



/*********************

 *      INCLUDES

 *********************/

#include "lv_port_disp_template.h"

#include <stdbool.h>

#include "main.h"



/*********************

 *      DEFINES

 *********************/



#define MY_DISP_HOR_RES    480

#define MY_DISP_VER_RES    272

/**********************

 *      TYPEDEFS

 **********************/



/**********************

 *  STATIC PROTOTYPES

 **********************/

static void disp_init(void);



static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);

//static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,

//        const lv_area_t * fill_area, lv_color_t color);



/**********************

 *  STATIC VARIABLES

 **********************/



/**********************

 *      MACROS

 **********************/



/**********************

 *   GLOBAL FUNCTIONS

 **********************/



void lv_port_disp_init(void)

{

    /*-------------------------

     * Initialize your display

     * -----------------------*/

    disp_init();



    /*-----------------------------

     * Create a buffer for drawing

     *----------------------------*/



    /**

     * LVGL requires a buffer where it internally draws the widgets.

     * Later this buffer will passed to your display driver's `flush_cb` to copy its content to your display.

     * The buffer has to be greater than 1 display row

     *

     * There are 3 buffering configurations:

     * 1. Create ONE buffer:

     *      LVGL will draw the display's content here and writes it to your display

     *

     * 2. Create TWO buffer:

     *      LVGL will draw the display's content to a buffer and writes it your display.

     *      You should use DMA to write the buffer's content to the display.

     *      It will enable LVGL to draw the next part of the screen to the other buffer while

     *      the data is being sent form the first buffer. It makes rendering and flushing parallel.

     *

     * 3. Double buffering

     *      Set 2 screens sized buffers and set disp_drv.full_refresh = 1.

     *      This way LVGL will always provide the whole rendered screen in `flush_cb`

     *      and you only need to change the frame buffer's address.

     */



    /* Example for 1) */

    static lv_disp_draw_buf_t draw_buf_dsc_1;

    static lv_color_t buf_1[MY_DISP_HOR_RES * 10];                          /*A buffer for 10 rows*/

    lv_disp_draw_buf_init(&draw_buf_dsc_1, buf_1, NULL, MY_DISP_HOR_RES * 10);   /*Initialize the display buffer*/



//    /* Example for 2) */

//    static lv_disp_draw_buf_t draw_buf_dsc_2;

//    static lv_color_t buf_2_1[MY_DISP_HOR_RES * 10];                        /*A buffer for 10 rows*/

//    static lv_color_t buf_2_2[MY_DISP_HOR_RES * 10];                        /*An other buffer for 10 rows*/

//    lv_disp_draw_buf_init(&draw_buf_dsc_2, buf_2_1, buf_2_2, MY_DISP_HOR_RES * 10);   /*Initialize the display buffer*/



//    /* Example for 3) also set disp_drv.full_refresh = 1 below*/

//    static lv_disp_draw_buf_t draw_buf_dsc_3;

//    static lv_color_t buf_3_1[MY_DISP_HOR_RES * MY_DISP_VER_RES];            /*A screen sized buffer*/

//    static lv_color_t buf_3_2[MY_DISP_HOR_RES * MY_DISP_VER_RES];            /*Another screen sized buffer*/

//    lv_disp_draw_buf_init(&draw_buf_dsc_3, buf_3_1, buf_3_2,

//                          MY_DISP_VER_RES * LV_VER_RES_MAX);   /*Initialize the display buffer*/



    /*-----------------------------------

     * Register the display in LVGL

     *----------------------------------*/



    static lv_disp_drv_t disp_drv;                         /*Descriptor of a display driver*/

    lv_disp_drv_init(&disp_drv);                    /*Basic initialization*/



    /*Set up the functions to access to your display*/



    /*Set the resolution of the display*/

    disp_drv.hor_res = MY_DISP_HOR_RES;

    disp_drv.ver_res = MY_DISP_VER_RES;



    /*Used to copy the buffer's content to the display*/

    disp_drv.flush_cb = disp_flush;



    /*Set a display buffer*/

    disp_drv.draw_buf = &draw_buf_dsc_1;



    /*Required for Example 3)*/

    //disp_drv.full_refresh = 1;



    /* Fill a memory array with a color if you have GPU.

     * Note that, in lv_conf.h you can enable GPUs that has built-in support in LVGL.

     * But if you have a different GPU you can use with this callback.*/

    //disp_drv.gpu_fill_cb = gpu_fill;



    /*Finally register the driver*/

    lv_disp_drv_register(&disp_drv);

}



/**********************

 *   STATIC FUNCTIONS

 **********************/



/*Initialize your display and the required peripherals.*/

static void disp_init(void)

{



}



volatile bool disp_flush_enabled = true;



/* Enable updating the screen (the flushing process) when disp_flush() is called by LVGL

 */

void disp_enable_update(void)

{

    disp_flush_enabled = true;

}



/* Disable updating the screen (the flushing process) when disp_flush() is called by LVGL

 */

void disp_disable_update(void)

{

    disp_flush_enabled = false;

}



/*Flush the content of the internal buffer the specific area on the display

 *You can use DMA or any hardware acceleration to do this operation in the background but

 *'lv_disp_flush_ready()' has to be called when finished.*/

static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)

{

    if(disp_flush_enabled) {

        /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/





        int32_t x;

        int32_t y;

        for(y = area->y1; y <= area->y2; y++) {

            for(x = area->x1; x <= area->x2; x++) {

                /*Put a pixel to the display. For example:*/

                /*put_px(x, y, *color_p)*/

                                                                UTIL_LCD_SetPixel(x, y, color_p->full);

                color_p++;

            }

        }

    }

        



    /*IMPORTANT!!!

     *Inform the graphics library that you are ready with the flushing*/

    lv_disp_flush_ready(disp_drv);

}

/*

 * Copy this file as `lv_conf.h`

 * 1. simply next to the `lvgl` folder

 * 2. or any other places and

 *    - define `LV_CONF_INCLUDE_SIMPLE`

 *    - add the path as include path

 */



/* clang-format off */

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



#ifndef LV_CONF_H

#define LV_CONF_H



#include <stdint.h>



/*====================

   COLOR SETTINGS

 *====================*/

 

 #define LV_HOR_RES_MAX  480

 #define LV_VER_RES_MAX  272



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

#define LV_COLOR_DEPTH 32



/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/

#define LV_COLOR_16_SWAP 0



/*Enable features to draw on transparent background.

 *It's required if opa, and transform_* style properties are used.

 *Can be also used if the UI is above another layer, e.g. an OSD menu or video player.*/

#define LV_COLOR_SCREEN_TRANSP 0



/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.

 * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */

#define LV_COLOR_MIX_ROUND_OFS 0



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

#include "main.h"

static void MPU_Config(void);

static void SystemClock_Config(void);

static void CPU_CACHE_Enable(void);

static void Error_Handler(void);



int main(void)

{

        uint32_t i=0;

  MPU_Config();

  CPU_CACHE_Enable();

  HAL_Init();

  SystemClock_Config(); 



        init_delay(400);

        init_led();

        init_uart3(115200);



        BSP_SDRAM_Init(0);

        BSP_LCD_Init(0, LCD_ORIENTATION_LANDSCAPE);

        UTIL_LCD_SetFuncDriver(&LCD_Driver);

        UTIL_LCD_Clear(UTIL_LCD_COLOR_RED);

 

        lv_init();

        lv_port_disp_init();

        lv_demo_stress();

  while (1)

  {

                HAL_Delay(5);

                lv_task_handler();

  }

}

void SysTick_Handler(void)

{

        lv_tick_inc(1);

  HAL_IncTick();

}