STM32 HAL|| 16 bit parallel LCD-TFT driver using FSMC interface for LVGL || DMA

 本文章介紹如何移植LVGL graphic library 到STM32上，另外說明有關LCD-TFT的driver使用STM32F4xx 的FSMC介面，STM32透過FSMC external memory access的方式驅動LCD-TFT。

一、使用硬體：

• LCD-TFT

• 開發版STM32_F4VE

二、STM32F4xx Bus matrix:

CPU or DMA透過Bus Matrix可直接存取FSMC。

三、STM407xx memory map:

使用FSMC bank1 其範圍為0x6000 0000~0x6fff ffff。

四、 FSMC write waveform and LCD-TFT write cycle sequence 的時序圖。

LCD-TFT D/CX:  Low時為command, High 實為GRAM data or commana的parameter data。相對於FSMC_A[25:0]的某一個address pin。

五、LCD-TFT Command&DATA address

本文章專案的FSMC設定如下圖：

LCD register select使用A18, 16 bits Data。因此A18為low時Address 為0x6000 0000代表command(D/CX low),。當A18為high 時Address 為0x6008 0000代表Data。

A[18]=HADDR[19]

六、移植LVGL library到STM32上：

1. copy lvgl中的scr資料夾與lvgl.h和lv_conf.h(由lv_conf_template.h更改檔名)檔案到專案中，並將檔案加到include paths中。
2. 設定定期呼叫lv_tick_inc(x)的timer，本專案設定為5ms。
   
   
   
   
3. 在main loop:定期呼叫lv_timer_handler()。
4. 呼叫lv_init()並設定display與input device的driver。

詳細程式碼附於文末。

七、成果展示：

八、程式碼：

• lcd_fsmc.c

#include <lcd_fsmc.h>
#include <stdlib.h>
#include <stdio.h>

static uint8_t LCD_Orientation=0;
static uint16_t lcd_width = LCD_WIDTH; //default 240
static uint16_t lcd_height = LCD_HEIGHT; //default 320

// MADCTL register: 			MY,MX,MV,ML,BGR,MH,x,x
static uint8_t LCD_MADCTL_PORTRAIT  		=	0b01001000;
static uint8_t LCD_MADCTL_LANDSCAPE  		=	0b00101000;
static uint8_t LCD_MADCTL_PORTRAIT_MIRROR  =	0b10001000;
static uint8_t LCD_MADCTL_LANDSCAPE_MIRROR = 	0b11101000;

void lcd_cmd_write(unsigned char command)
{
	LCD_CMD_WRITE(command);
}

void lcd_data_write(unsigned short data)
{
	LCD_DATA_WRITE(data);
}

uint16_t lcd_get_width() {
	return lcd_width;
}

uint16_t lcd_get_height() {
	return lcd_height;
}

static void lcd_reset(void)
{
	lcd_cmd_write(LCD_SOFTRESET);
	HAL_Delay(50);
}

void lcd_set_window(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1)
{
  lcd_cmd_write(LCD_COLADDRSET);
  lcd_data_write((x0 >> 8) & 0xFF);
  lcd_data_write(x0 & 0xFF);
  lcd_data_write((x1 >> 8) & 0xFF);
  lcd_data_write(x1 & 0xFF);
  lcd_cmd_write(LCD_PAGEADDRSET);
  lcd_data_write((y0 >> 8) & 0xFF);
  lcd_data_write(y0 & 0xFF);
  lcd_data_write((y1 >> 8) & 0xFF);
  lcd_data_write(y1 & 0xFF);
  lcd_cmd_write(LCD_MEMORYWRITE);
}

void lcd_init(void)
{
  lcd_reset();

  lcd_cmd_write(LCD_DISPLAYOFF);

  lcd_cmd_write(0xCF);
  lcd_data_write(0x00);
  lcd_data_write(0x83);
  lcd_data_write(0x30);

  lcd_cmd_write(0xED);
  lcd_data_write(0x64);
  lcd_data_write(0x03);
  lcd_data_write(0x12);
  lcd_data_write(0x81);

  lcd_cmd_write(0xE8);
  lcd_data_write(0x85);
  lcd_data_write(0x01);
  lcd_data_write(0x79);

  lcd_cmd_write(0xCB);
  lcd_data_write(0x39);
  lcd_data_write(0x2C);
  lcd_data_write(0x00);
  lcd_data_write(0x34);
  lcd_data_write(0x02);

  lcd_cmd_write(0xF7);
  lcd_data_write(0x20);

  lcd_cmd_write(0xEA);
  lcd_data_write(0x00);
  lcd_data_write(0x00);

  lcd_cmd_write(LCD_POWERCONTROL1);
  lcd_data_write(0x26);

  lcd_cmd_write(LCD_POWERCONTROL2);
  lcd_data_write(0x11);

  lcd_cmd_write(LCD_VCOMCONTROL1);
  lcd_data_write(0x35);
  lcd_data_write(0x3E);

  lcd_cmd_write(LCD_VCOMCONTROL2);
  lcd_data_write(0xBE);

  lcd_cmd_write(LCD_MEMCONTROL);
  lcd_data_write(LCD_MADCTL_PORTRAIT);
  LCD_Orientation = LCD_ORIENTATION_PORTRAIT; // set TFT orientation default

  lcd_cmd_write(LCD_PIXELFORMAT);
  lcd_data_write(0x55);

  lcd_cmd_write(LCD_FRAMECONTROLNORMAL);
  lcd_data_write(0x00);
  lcd_data_write(0x1B);

  lcd_cmd_write(0xF2);
  lcd_data_write(0x08);

  lcd_cmd_write(LCD_GAMMASET);
  lcd_data_write(0x01);

  lcd_cmd_write(LCD_POSITIVEGAMMCORR);
  lcd_data_write(0x1F);
  lcd_data_write(0x1A);
  lcd_data_write(0x18);
  lcd_data_write(0x0A);
  lcd_data_write(0x0F);
  lcd_data_write(0x06);
  lcd_data_write(0x45);
  lcd_data_write(0x87);
  lcd_data_write(0x32);
  lcd_data_write(0x0A);
  lcd_data_write(0x07);
  lcd_data_write(0x02);
  lcd_data_write(0x07);
  lcd_data_write(0x05);
  lcd_data_write(0x00);

  lcd_cmd_write(LCD_NEGATIVEGAMMCORR);
  lcd_data_write(0x00);
  lcd_data_write(0x25);
  lcd_data_write(0x27);
  lcd_data_write(0x05);
  lcd_data_write(0x10);
  lcd_data_write(0x09);
  lcd_data_write(0x3A);
  lcd_data_write(0x78);
  lcd_data_write(0x4D);
  lcd_data_write(0x05);
  lcd_data_write(0x18);
  lcd_data_write(0x0D);
  lcd_data_write(0x38);
  lcd_data_write(0x3A);
  lcd_data_write(0x1F);

  lcd_cmd_write(LCD_COLADDRSET);
  lcd_data_write(0x00);
  lcd_data_write(0x00);
  lcd_data_write(0x00);
  lcd_data_write(0xEF);

  lcd_cmd_write(LCD_PAGEADDRSET);
  lcd_data_write(0x00);
  lcd_data_write(0x00);
  lcd_data_write(0x01);
  lcd_data_write(0x3F);

  lcd_cmd_write(LCD_ENTRYMODE);
  lcd_data_write(0x07);

  lcd_cmd_write(LCD_DISPLAYFUNC);
  lcd_data_write(0x0A);
  lcd_data_write(0x82);
  lcd_data_write(0x27);
  lcd_data_write(0x00);

  lcd_cmd_write(LCD_SLEEPOUT);
  HAL_Delay(100);
  lcd_cmd_write(LCD_DISPLAYON);
  HAL_Delay(100);
  lcd_cmd_write(LCD_MEMORYWRITE);
}

void lcd_set_orientation(uint8_t Orientation)
{
	LCD_Orientation = Orientation;
	lcd_cmd_write(LCD_MEMCONTROL);

	switch (LCD_Orientation)
	{
		case LCD_ORIENTATION_PORTRAIT:
			lcd_data_write(LCD_MADCTL_PORTRAIT);
			lcd_width = LCD_WIDTH;
			lcd_height = LCD_HEIGHT;
			break;
		case LCD_ORIENTATION_PORTRAIT_MIRROR:
			lcd_data_write(LCD_MADCTL_PORTRAIT_MIRROR);
			lcd_width = LCD_WIDTH;
			lcd_height = LCD_HEIGHT;
			break;
		case LCD_ORIENTATION_LANDSCAPE:
			lcd_data_write(LCD_MADCTL_LANDSCAPE);
			lcd_width = LCD_HEIGHT;
			lcd_height = LCD_WIDTH;
			break;
		case LCD_ORIENTATION_LANDSCAPE_MIRROR:
			lcd_data_write(LCD_MADCTL_LANDSCAPE_MIRROR);
			lcd_width = LCD_HEIGHT;
			lcd_height = LCD_WIDTH;
			break;
		default:
			break;
	}

	lcd_cmd_write(LCD_MEMORYWRITE);
	lcd_set_window(0, 0, lcd_width - 1, lcd_height - 1);
}

void lcd_backlight_off(void)
{
	LCD_BL_OFF();
}

void lcd_backlight_on(void)
{
	LCD_BL_ON();
}

void lcd_display_off(void)
{
	lcd_cmd_write(LCD_DISPLAYOFF);
	LCD_BL_OFF();
}

void lcd_display_on(void)
{
	lcd_cmd_write(LCD_DISPLAYON);
	LCD_BL_ON();
}

uint8_t lcd_get_orientation(void)
{
  return LCD_Orientation;
}


void lcd_fill_RGB(uint16_t color, uint16_t x, uint16_t y, uint16_t width, uint16_t height)
{
  lcd_set_window(x, y, x+width - 1, y+height - 1);
  int dimensions = width * height;
  while(dimensions--)
  {
    lcd_data_write(color);
  }
}

  

• lcd_fsmc.h

#ifndef __LCD_FSMC_H_
#define __LCD_FSMC_H_

#include "main.h"
#include <stdbool.h>

#define LCD_WIDTH		240
#define LCD_HEIGHT 		320

#define LCD_BL_ON() HAL_GPIO_WritePin(LCD_BL_GPIO_Port, LCD_BL_Pin, GPIO_PIN_RESET)
#define LCD_BL_OFF() HAL_GPIO_WritePin(LCD_BL_GPIO_Port, LCD_BL_Pin, GPIO_PIN_SET)

#define LCD_CMD_BASE        		((uint32_t)0x60000000)
#define LCD_DATA_BASE        		((uint32_t)0x60080000)

#define LCD_CMD_WRITE(command)	*(volatile uint16_t *) (LCD_CMD_BASE) = (command)
#define LCD_DATA_WRITE(data)	*(volatile uint16_t *) (LCD_DATA_BASE) = (data)
#define	LCD_REGISTER_READ()		*(volatile uint16_t *) (LCD_CMD_BASE)
#define	LCD_DATA_READ()			*(volatile uint16_t *) (LCD_DATA_BASE)

enum
{
	LCD_ORIENTATION_PORTRAIT 			= 0,
	LCD_ORIENTATION_LANDSCAPE 			= 1,
	LCD_ORIENTATION_PORTRAIT_MIRROR 	= 2,
	LCD_ORIENTATION_LANDSCAPE_MIRROR 	= 3
};

// LCD registers
#define	LCD_NOP					0x00
#define LCD_SOFTRESET			0x01
#define LCD_READID				0x04
#define LCD_READSTATUS			0x09
#define LCD_READPOWERMODE		0x0A
#define LCD_READMADCTL			0x0B
#define LCD_READPIXELFORMAT		0x0C
#define LCD_READIMAGEFORMAT		0x0D
#define LCD_READSIGNALMODE		0x0E
#define LCD_READSELFDIAGNOSTIC	0x0F
#define LCD_SLEEPIN				0x10
#define LCD_SLEEPOUT			0x11
#define LCD_PARTIALMODE			0x12
#define LCD_NORMALDISP			0x13
#define LCD_INVERTOFF			0x20
#define LCD_INVERTON			0x21
#define LCD_GAMMASET			0x26
#define LCD_DISPLAYOFF			0x28
#define LCD_DISPLAYON			0x29
#define LCD_COLADDRSET			0x2A
#define LCD_PAGEADDRSET			0x2B
#define LCD_MEMORYWRITE			0x2C
#define LCD_COLORSET			0x2D
#define LCD_MEMORYREAD			0x2E
#define LCD_PARTIALAREA			0x30
#define LCD_VERTICALSCROLING	0x33
#define LCD_TEARINGEFFECTOFF	0x34
#define LCD_TEARINGEFFECTON		0x35
#define LCD_MEMCONTROL			0x36
#define LCD_VSCROLLSTARTADDRESS	0x37
#define LCD_IDLEMODEOFF			0x38
#define LCD_IDLEMODEON			0x39
#define LCD_PIXELFORMAT			0x3A
#define LCD_WRITEMEMCONTINUE	0x3C
#define LCD_READMEMCONTINUE		0x3E
#define LCD_SETSCANLINE			0x44
#define LCD_GETSCANLINE			0x45
#define LCD_WRITEBRIGHTNESS		0x51
#define LCD_READBRIGHTNESS		0x52
#define LCD_WRITECTRL			0x53
#define LCD_READCTRL			0x54
#define LCD_WRITECABC			0x55
#define LCD_READCABC			0x56
#define LCD_WRITECABCMIN		0x5E
#define LCD_READCABCMIN			0x5F
#define LCD_RGBSIGNALCONTROL	0xB0
#define LCD_FRAMECONTROLNORMAL	0xB1
#define LCD_FRAMECONTROLIDLE	0xB2
#define LCD_FRAMECONTROLPARTIAL	0xB3
#define LCD_INVERSIONCONTROL	0xB4
#define LCD_BLANKINGPORCHCONT	0xB5
#define LCD_DISPLAYFUNC			0xB6
#define LCD_ENTRYMODE			0xB7
#define LCD_BACKLIGHTCONTROL1	0xB8
#define LCD_BACKLIGHTCONTROL2	0xB9
#define LCD_BACKLIGHTCONTROL3	0xBA
#define LCD_BACKLIGHTCONTROL4	0xBB
#define LCD_BACKLIGHTCONTROL5	0xBC
#define LCD_BACKLIGHTCONTROL7	0xBE
#define LCD_BACKLIGHTCONTROL8	0xBF
#define LCD_POWERCONTROL1		0xC0
#define LCD_POWERCONTROL2		0xC1
#define LCD_VCOMCONTROL1		0xC5
#define LCD_VCOMCONTROL2		0xC7
#define LCD_NVMEMORYWRITE		0xD0
#define LCD_NVMEMORYKEY			0xD1
#define LCD_NVMEMORYSTATUSREAD	0xD2
#define LCD_READID4				0xD3
#define LCD_READID1				0xDA
#define LCD_READID2				0xDB
#define LCD_READID3				0xDC
#define LCD_POSITIVEGAMMCORR	0xE0
#define LCD_NEGATIVEGAMMCORR	0xE1
#define LCD_DIGITALGAMMCONTROL1	0xE2
#define LCD_DIGITALGAMMCONTROL2	0xE3
#define LCD_INTERFACECONTROL	0xF6
// LCD Registers

void lcd_init(void);
void lcd_fill_RGB(uint16_t color, uint16_t x, uint16_t y, uint16_t width, uint16_t height);
void lcd_set_orientation(uint8_t Orientation);
void lcd_set_window(unsigned short x0, unsigned short y0, unsigned short x1, unsigned short y1);
void lcd_display_off(void);
void lcd_display_on(void);
void lcd_data_write(unsigned short data);
void lcd_cmd_write(unsigned char command);
void lcd_backlight_on();
void lcd_backlight_off();

uint16_t lcd_get_width();
uint16_t lcd_get_height();
uint8_t lcd_get_orientation();



#endif /* __LCD_FSMC_H_ */

  

• lcd_lvgl.c

#include <lcd_lvgl.h>

/* Memory-to-memory DMA Handler */
extern DMA_HandleTypeDef hdma_memtomem_dma2_stream0;

extern uint8_t test_with_dma;
void tft_lvgl_draw_bitmap(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t *bitmap)
{
	uint32_t total_pixels = (x2-x1+1) * (y2-y1+1);

	lcd_set_window(x1, y1, x2, y2);

	// use memory-to-memory DMA
	HAL_DMA_Start(&hdma_memtomem_dma2_stream0, (uint32_t)bitmap, (LCD_DATA_BASE), total_pixels);
	HAL_DMA_PollForTransfer(&hdma_memtomem_dma2_stream0, HAL_DMA_FULL_TRANSFER, 1000);

	// if not use DMA translation
	//	for (int i=0; i < total_pixels; i++) {
	//		lcd_data_write(*(bitmap+i));
	//	}

}

void tft_lvgl_disp_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p)
{
    tft_lvgl_draw_bitmap(
            (uint16_t)(area->x1),
            (uint16_t)(area->y1),
            (uint16_t)(area->x2),
            (uint16_t)(area->y2), (uint16_t*)color_p
            );

    lv_disp_flush_ready(disp);         /* Indicate you are ready with the flushing*/
}


void lvgl_init() {
	lv_init();

	static lv_disp_draw_buf_t draw_buf;
	static lv_color_t buf1[LCD_WIDTH * LCD_HEIGHT / 10];                        /*Declare a buffer for 1/10 screen size*/
	lv_disp_draw_buf_init(&draw_buf, buf1, NULL, LCD_WIDTH * LCD_HEIGHT / 10);  /*Initialize the display buffer.*/

	static lv_disp_drv_t disp_drv;        /*Descriptor of a display driver*/
	lv_disp_drv_init(&disp_drv);          /*Basic initialization*/
	disp_drv.flush_cb = tft_lvgl_disp_flush;    /*Set your driver function*/
	disp_drv.draw_buf = &draw_buf;        /*Assign the buffer to the display*/
	disp_drv.hor_res = lcd_get_width();   /*Set the horizontal resolution of the display*/
	disp_drv.ver_res = lcd_get_height();   /*Set the vertical resolution of the display*/
	lv_disp_drv_register(&disp_drv);      /*Finally register the driver*/

}

void lvgl_xpt2046_read_cb(lv_indev_drv_t * drv, lv_indev_data_t*data)
{
	static uint16_t x, y;
	if(XPT2046_TouchPressed()) {
		XPT2046_TouchGetCoordinates(&x, &y);
		data->point.x = x;
		data->point.y = y;
		data->state = LV_INDEV_STATE_PRESSED;
	} else {
		data->state = LV_INDEV_STATE_RELEASED;
	}
}

void lvgl_xpt2046_touch_init() {
	static lv_indev_drv_t indev_drv;
	lv_indev_drv_init(&indev_drv);      	/*Basic initialization*/
	indev_drv.type = LV_INDEV_TYPE_POINTER;
	indev_drv.read_cb = lvgl_xpt2046_read_cb;
	/*Register the driver in LVGL and save the created input device object*/
	lv_indev_drv_register(&indev_drv);
}


  

• lcd_lvgl.h

#ifndef __LCD_LVGL_H
#define __LCD_LVGL_H

#include <lcd_fsmc.h>
#include <lvgl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "XPT2046_touch.h"


void lvgl_init();
void lvgl_xpt2046_touch_init();

#endif /*__LCD_LVGL_H */

  

• XPT2046_touch.c

#include <lcd_fsmc.h>
#include <stdio.h>
#include <stdlib.h>
#include "XPT2046_touch.h"


#define READ_X 0xD0
#define READ_Y 0x90


uint16_t cRawX_min = XPT2046_MIN_RAW_X;
uint16_t cRawX_max = XPT2046_MAX_RAW_X;
uint16_t cRawY_min = XPT2046_MIN_RAW_Y;
uint16_t cRawY_max = XPT2046_MAX_RAW_Y;


static void XPT2046_TouchSelect()
{
    HAL_GPIO_WritePin(XPT2046_CS_GPIO_Port, XPT2046_CS_Pin, GPIO_PIN_RESET);
}

void XPT2046_TouchUnselect()
{
    HAL_GPIO_WritePin(XPT2046_CS_GPIO_Port, XPT2046_CS_Pin, GPIO_PIN_SET);
}

bool XPT2046_TouchPressed()
{
    return HAL_GPIO_ReadPin(XPT2046_IRQ_GPIO_Port, XPT2046_IRQ_Pin) == GPIO_PIN_RESET;
}

bool XPT2046_TouchGetCoordinates(uint16_t* x, uint16_t* y)
{
	bool ret_value=false;
	uint16_t tx,ty;
	uint32_t raw_x;
	uint32_t raw_y;
	if (XPT2046_TouchGetRawCoordinates(&raw_x, &raw_y))
	{
		if(raw_x < cRawX_min) raw_x = cRawX_min;
		if(raw_x > cRawX_max) raw_x = cRawX_max;

		if(raw_y < cRawY_min) raw_y = cRawY_min;
		if(raw_y > cRawY_max) raw_y = cRawY_max;

		tx = (raw_x - cRawX_min) * XPT2046_SCALE_X / (cRawX_max - cRawX_min);
		ty = (raw_y - cRawY_min) * XPT2046_SCALE_Y / (cRawY_max - cRawY_min);

		uint8_t lot = lcd_get_orientation();
		switch (lot)
		{
		case LCD_ORIENTATION_PORTRAIT:
			*x=tx;
			*y=ty;
			break;
		case LCD_ORIENTATION_LANDSCAPE:
			*x=ty;
			*y=LCD_WIDTH-tx;
					break;
		case LCD_ORIENTATION_PORTRAIT_MIRROR:
			*x=LCD_WIDTH-tx;
			*y=LCD_HEIGHT-ty;
					break;
		case LCD_ORIENTATION_LANDSCAPE_MIRROR:
			*x=LCD_HEIGHT-ty;
			*y=tx;
			break;
		}
		ret_value =true;
    }
	return ret_value;

}
bool XPT2046_TouchGetRawCoordinates(uint32_t* raw_x, uint32_t* raw_y)
{
    static const uint8_t cmd_read_x[] = { READ_X };
    static const uint8_t cmd_read_y[] = { READ_Y };
    static const uint8_t zeroes_tx[] = { 0x00, 0x00 };
    static const uint8_t SAMPLES=16;

    //if (!XPT2046_TouchPressed()) return false;
    //HAL_Delay(10);
    XPT2046_TouchSelect();

    uint32_t avg_x = 0;
    uint32_t avg_y = 0;
    uint8_t nsamples = 0;


    for(uint8_t i = 0; i < SAMPLES; i++)
    {
        if(!XPT2046_TouchPressed()) {
            break;
        }

        nsamples++;

        HAL_SPI_Transmit(&XPT2046_SPI_PORT, (uint8_t*)cmd_read_y, sizeof(cmd_read_y), HAL_MAX_DELAY);
        uint8_t y_raw[2];
        HAL_SPI_TransmitReceive(&XPT2046_SPI_PORT, (uint8_t*)zeroes_tx, y_raw, sizeof(y_raw), HAL_MAX_DELAY);

        HAL_SPI_Transmit(&XPT2046_SPI_PORT, (uint8_t*)cmd_read_x, sizeof(cmd_read_x), HAL_MAX_DELAY);
        uint8_t x_raw[2];
        HAL_SPI_TransmitReceive(&XPT2046_SPI_PORT, (uint8_t*)zeroes_tx, x_raw, sizeof(x_raw), HAL_MAX_DELAY);

        avg_x += (((uint16_t)x_raw[0]) << 8) | ((uint16_t)x_raw[1]);
        avg_y += (((uint16_t)y_raw[0]) << 8) | ((uint16_t)y_raw[1]);
    }

    XPT2046_TouchUnselect();

    if(nsamples < SAMPLES)
        return false;

    *raw_x = (avg_x / SAMPLES);
    *raw_y = (avg_y / SAMPLES);
    return true;

}

bool XPT2046_TouchCalibration()
{
	uint32_t x0=0,y0=0,x1=0,y1=0,x2=0,y2=0,x3=0,y3=0;
	bool correct=true;
	uint32_t width, height;
	uint8_t lot = lcd_get_orientation();
	lcd_set_orientation(LCD_ORIENTATION_PORTRAIT);
	width = lcd_get_width();
	height = lcd_get_height();
	lcd_fill_RGB(0x0000, 0, 0, width-1, height-1);



	lcd_fill_RGB(0xffff, 0, 0, 6,6);
	lcd_set_window(20,100 ,20 ,100);  // set LCD cursor to (20,100)
	while(!XPT2046_TouchPressed()) ;
	if (!XPT2046_TouchGetRawCoordinates(&x0, &y0))
	{
		lcd_set_orientation(lot);
		return false;
	}
	lcd_fill_RGB(0x0000, 0, 0, width-1, height-1);
	lcd_fill_RGB(0xffff, 0, height-7, 6, 6);

	while(XPT2046_TouchPressed());
	HAL_Delay(1);

	lcd_set_window(20, 100, 20, 100);
	while(!XPT2046_TouchPressed());
	if(!XPT2046_TouchGetRawCoordinates(&x1, &y1))
	{
		lcd_set_orientation(lot);
		return false;
	}
	lcd_fill_RGB(0x0000, 0, 0, width-1, height-1);
	lcd_fill_RGB(0xffff,width-7, height-7, 6, 6);
	while(XPT2046_TouchPressed());
	HAL_Delay(1);


	lcd_set_window(20, 100, 20, 100);
	while(!XPT2046_TouchPressed());
	if (!XPT2046_TouchGetRawCoordinates(&x2, &y2))
	{
		lcd_set_orientation(lot);
		return false;
	}
	lcd_fill_RGB(0x0000, 0, 0, width-1, height-1);
	lcd_fill_RGB(0xffff, width-7, 0, 6, 6);
	while(XPT2046_TouchPressed());
	HAL_Delay(1);

	lcd_set_window(20, 100, 20, 100);
	while(!XPT2046_TouchPressed());
	if (!XPT2046_TouchGetRawCoordinates(&x3, &y3))
	{
		lcd_set_orientation(lot);
		return false;
	}
	while(XPT2046_TouchPressed());

	if (abs(x0-x1) > XTP2046_CALI_DIFF) correct = false;
	if (abs(x2-x3) > XTP2046_CALI_DIFF) correct = false;
	if (abs(y1-y2) > XTP2046_CALI_DIFF) correct = false;
	if (abs(y0-y3) > XTP2046_CALI_DIFF) correct = false;
	if (correct) {
		cRawX_min = (x0+x1)/2;
		cRawX_max = (x2+x3)/2;
		cRawY_min = (y0+y3)/2;
		cRawY_max = (y1+y2)/2;
	}

	lcd_fill_RGB(0x0000, 0, 0, width-1, height-1);
	lcd_set_window(20, 100, 20, 100);
	lcd_set_orientation(lot);
	return correct;
}

• XPT2046_touch.h

#ifndef XPT2046_TOUCH_H_
#define XPT2046_TOUCH_H_

#include "main.h"
#include <stdbool.h>

/*** Redefine if necessary ***/

// Warning! Use SPI bus with < 2.5 Mbit speed, better ~650 Kbit to be save.
#define XPT2046_SPI_PORT hspi2
extern SPI_HandleTypeDef XPT2046_SPI_PORT;

#define XPT2046_IRQ_Pin       T_IRQ_Pin
#define XPT2046_IRQ_GPIO_Port T_IRQ_GPIO_Port
#define XPT2046_CS_Pin        T_CS_Pin
#define XPT2046_CS_GPIO_Port  T_CS_GPIO_Port

// change depending on screen orientation
#define XPT2046_SCALE_X 240
#define XPT2046_SCALE_Y 320

#define XPT2046_MIN_RAW_X 1860
#define XPT2046_MAX_RAW_X 29650
#define XPT2046_MIN_RAW_Y 1830
#define XPT2046_MAX_RAW_Y 29350

//#define XPT2046_MIN_RAW_X 2000
//#define XPT2046_MAX_RAW_X 30000
//#define XPT2046_MIN_RAW_Y 1500
//#define XPT2046_MAX_RAW_Y 29000

#define XTP2046_CALI_DIFF	2500

// call before initializing any SPI devices
void XPT2046_TouchUnselect(void);
bool XPT2046_TouchPressed(void);
bool XPT2046_TouchGetCoordinates(uint16_t* x, uint16_t* y);
bool XPT2046_TouchGetRawCoordinates(uint32_t* raw_, uint32_t* raw_y);
bool XPT2046_TouchCalibration(void);

#endif /* XPT2046_TOUCH_H_ */

• main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "XPT2046_touch.h"
#include "lcd_fsmc.h"
#include "lcd_lvgl.h"
#include "sht40.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

SD_HandleTypeDef hsd;
DMA_HandleTypeDef hdma_sdio_rx;
DMA_HandleTypeDef hdma_sdio_tx;

SPI_HandleTypeDef hspi2;

TIM_HandleTypeDef htim3;

DMA_HandleTypeDef hdma_memtomem_dma2_stream0;
SRAM_HandleTypeDef hsram1;

/* USER CODE BEGIN PV */
void demo_screen_rotation();
void dma_demo();
void sd_img_dma_demo();
void temp_humi_demo();

float sht40_temp, sht40_humi;
extern lv_obj_t* temp_bar;
extern lv_obj_t* humi_meter;
extern lv_meter_indicator_t * humi_indic;
extern uint8_t test_with_dma;

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_FSMC_Init(void);
static void MX_SPI2_Init(void);
static void MX_TIM3_Init(void);
static void MX_I2C1_Init(void);
static void MX_SDIO_SD_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* tim) {

	lv_tick_inc(5);
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_FSMC_Init();
  MX_SPI2_Init();
  MX_TIM3_Init();
  MX_I2C1_Init();
  MX_SDIO_SD_Init();
  MX_FATFS_Init();
  /* USER CODE BEGIN 2 */
  f_mount(&SDFatFS, SDPath, 1);



  HAL_TIM_Base_Start_IT(&htim3);
  HAL_I2C_Init(&hi2c1);

  lcd_backlight_on();
  lcd_init();
  lcd_set_orientation(LCD_ORIENTATION_LANDSCAPE);

  //while(!XPT2046_TouchCalibration()) {HAL_Delay(100);}

  lvgl_init();
  lvgl_xpt2046_touch_init();

dma_demo();
 HAL_Delay(5000);
 lv_obj_clean(lv_scr_act());
  test_with_dma=1;
  for (int i=0; i < 2; i++) {
	  test_with_dma = (test_with_dma+1)%2;
	  sd_img_dma_demo();
	  lv_obj_clean(lv_scr_act());
  }

  //demo_screen_rotation();
  temp_humi_demo();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */

  uint32_t count=0;
  while (1)
  {
	  lv_timer_handler();
	  HAL_Delay(5);

	  if (count > 400) {
		  count = 0;
		  sht40_get_th_data(&sht40_temp, &sht40_humi);
		  lv_bar_set_value(temp_bar, (int32_t)sht40_temp, LV_ANIM_ON);

		  lv_meter_set_indicator_end_value(humi_meter, humi_indic, sht40_humi);
	  }
	  count++;

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 168;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief I2C1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 400000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_Init 2 */

}

/**
  * @brief SDIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_SDIO_SD_Init(void)
{

  /* USER CODE BEGIN SDIO_Init 0 */

  /* USER CODE END SDIO_Init 0 */

  /* USER CODE BEGIN SDIO_Init 1 */

  /* USER CODE END SDIO_Init 1 */
  hsd.Instance = SDIO;
  hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
  hsd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
  hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
  hsd.Init.BusWide = SDIO_BUS_WIDE_4B;
  hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
  hsd.Init.ClockDiv = 0;
  /* USER CODE BEGIN SDIO_Init 2 */
  hsd.Init.BusWide = SDIO_BUS_WIDE_1B;
  /* USER CODE END SDIO_Init 2 */

}

/**
  * @brief SPI2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI2_Init(void)
{

  /* USER CODE BEGIN SPI2_Init 0 */

  /* USER CODE END SPI2_Init 0 */

  /* USER CODE BEGIN SPI2_Init 1 */

  /* USER CODE END SPI2_Init 1 */
  /* SPI2 parameter configuration*/
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */

}

/**
  * @brief TIM3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 42000-1;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 10-1;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */


  /* USER CODE END TIM3_Init 2 */

}

/**
  * Enable DMA controller clock
  * Configure DMA for memory to memory transfers
  *   hdma_memtomem_dma2_stream0
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* Configure DMA request hdma_memtomem_dma2_stream0 on DMA2_Stream0 */
  hdma_memtomem_dma2_stream0.Instance = DMA2_Stream0;
  hdma_memtomem_dma2_stream0.Init.Channel = DMA_CHANNEL_0;
  hdma_memtomem_dma2_stream0.Init.Direction = DMA_MEMORY_TO_MEMORY;
  hdma_memtomem_dma2_stream0.Init.PeriphInc = DMA_PINC_ENABLE;
  hdma_memtomem_dma2_stream0.Init.MemInc = DMA_MINC_DISABLE;
  hdma_memtomem_dma2_stream0.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
  hdma_memtomem_dma2_stream0.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
  hdma_memtomem_dma2_stream0.Init.Mode = DMA_NORMAL;
  hdma_memtomem_dma2_stream0.Init.Priority = DMA_PRIORITY_LOW;
  hdma_memtomem_dma2_stream0.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
  hdma_memtomem_dma2_stream0.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
  hdma_memtomem_dma2_stream0.Init.MemBurst = DMA_MBURST_SINGLE;
  hdma_memtomem_dma2_stream0.Init.PeriphBurst = DMA_PBURST_SINGLE;
  if (HAL_DMA_Init(&hdma_memtomem_dma2_stream0) != HAL_OK)
  {
    Error_Handler( );
  }

  /* DMA interrupt init */
  /* DMA2_Stream3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
  /* DMA2_Stream6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LCD_BL_GPIO_Port, LCD_BL_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(T_CS_GPIO_Port, T_CS_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pins : PC4 T_IRQ_Pin */
  GPIO_InitStruct.Pin = GPIO_PIN_4|T_IRQ_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : LCD_BL_Pin T_CS_Pin */
  GPIO_InitStruct.Pin = LCD_BL_Pin|T_CS_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* FSMC initialization function */
static void MX_FSMC_Init(void)
{

  /* USER CODE BEGIN FSMC_Init 0 */

  /* USER CODE END FSMC_Init 0 */

  FSMC_NORSRAM_TimingTypeDef Timing = {0};

  /* USER CODE BEGIN FSMC_Init 1 */

  /* USER CODE END FSMC_Init 1 */

  /** Perform the SRAM1 memory initialization sequence
  */
  hsram1.Instance = FSMC_NORSRAM_DEVICE;
  hsram1.Extended = FSMC_NORSRAM_EXTENDED_DEVICE;
  /* hsram1.Init */
  hsram1.Init.NSBank = FSMC_NORSRAM_BANK1;
  hsram1.Init.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE;
  hsram1.Init.MemoryType = FSMC_MEMORY_TYPE_SRAM;
  hsram1.Init.MemoryDataWidth = FSMC_NORSRAM_MEM_BUS_WIDTH_16;
  hsram1.Init.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE;
  hsram1.Init.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW;
  hsram1.Init.WrapMode = FSMC_WRAP_MODE_DISABLE;
  hsram1.Init.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS;
  hsram1.Init.WriteOperation = FSMC_WRITE_OPERATION_ENABLE;
  hsram1.Init.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE;
  hsram1.Init.ExtendedMode = FSMC_EXTENDED_MODE_DISABLE;
  hsram1.Init.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE;
  hsram1.Init.WriteBurst = FSMC_WRITE_BURST_DISABLE;
  hsram1.Init.PageSize = FSMC_PAGE_SIZE_NONE;
  /* Timing */
  Timing.AddressSetupTime = 6;
  Timing.AddressHoldTime = 15;
  Timing.DataSetupTime = 4;
  Timing.BusTurnAroundDuration = 4;
  Timing.CLKDivision = 16;
  Timing.DataLatency = 17;
  Timing.AccessMode = FSMC_ACCESS_MODE_A;
  /* ExtTiming */

  if (HAL_SRAM_Init(&hsram1, &Timing, NULL) != HAL_OK)
  {
    Error_Handler( );
  }

  /* USER CODE BEGIN FSMC_Init 2 */

  /* USER CODE END FSMC_Init 2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

• demo.c

#include <lcd_fsmc.h>
#include "lvgl.h"
#include <stdio.h>
#include <stdlib.h>

static lv_obj_t * arc;
extern float sht40_temp, sht40_numi;

static void arc_value_changed_event_cb(lv_event_t * e)
{
    lv_obj_t * arc = lv_event_get_target(e);
    lv_obj_t * label = lv_event_get_user_data(e);

    lv_label_set_text_fmt(label, "%d%%", lv_arc_get_value(arc));
    lv_arc_align_obj_to_angle(arc, label, 25);

    //lv_arc_rotate_obj_to_angle(arc, label, 25);
}

void mbtn_cb(lv_event_t* e) {

	lv_arc_set_value(arc, lv_arc_get_value(arc)-1);
	lv_event_send(arc, LV_EVENT_VALUE_CHANGED, NULL);
}

void pbtn_cb(lv_event_t* e) {

	lv_arc_set_value(arc, lv_arc_get_value(arc)+1);
	lv_event_send(arc, LV_EVENT_VALUE_CHANGED, NULL);
}

void rbtn_cb(lv_event_t* e) {
	uint8_t rot = lcd_get_orientation();
	lcd_set_orientation((rot+1)%4);
	lv_disp_t* disp = lv_disp_get_default();
	disp->driver->hor_res = lcd_get_width();
	disp->driver->ver_res = lcd_get_height();

	lv_disp_set_rotation(disp, LV_DISP_ROT_NONE);

}

void demo_screen_rotation() {
	lv_obj_t * label = lv_label_create(lv_scr_act());

	arc = lv_arc_create(lv_scr_act());
	lv_obj_set_size(arc, 170, 170);
	lv_arc_set_rotation(arc, 150);
	lv_arc_set_bg_angles(arc, 0, 240);
	lv_arc_set_mode(arc, LV_ARC_MODE_SYMMETRICAL);
	lv_arc_set_value(arc, 50);
	lv_obj_align(arc,LV_ALIGN_TOP_MID, 0, 25);
	lv_obj_add_event_cb(arc, arc_value_changed_event_cb, LV_EVENT_VALUE_CHANGED, label);


	lv_event_send(arc, LV_EVENT_VALUE_CHANGED, NULL);

	lv_obj_t *pbtn = lv_btn_create(lv_scr_act());
	lv_obj_t *plabel = lv_label_create(pbtn);
	lv_label_set_text(plabel, LV_SYMBOL_PLUS);
	lv_obj_align(pbtn, LV_ALIGN_BOTTOM_MID, 30, -20);
	lv_obj_set_size(pbtn, 40, 30);
	lv_obj_add_event_cb(pbtn, pbtn_cb, LV_EVENT_CLICKED, NULL);

	lv_obj_t *mbtn = lv_btn_create(lv_scr_act());
	lv_obj_t *mlabel = lv_label_create(mbtn);
	lv_label_set_text(mlabel, LV_SYMBOL_MINUS);
	lv_obj_align(mbtn, LV_ALIGN_BOTTOM_MID, -30, -20);
	lv_obj_set_size(mbtn, 40, 30);
	lv_obj_add_event_cb(mbtn, mbtn_cb, LV_EVENT_CLICKED, NULL);

	lv_obj_t *rbtn = lv_btn_create(lv_scr_act());
	lv_obj_t *rlabel = lv_label_create(rbtn);
	lv_label_set_text(rlabel, "R");
	lv_obj_align(rbtn, LV_ALIGN_BOTTOM_RIGHT, -10, -20);
	lv_obj_set_size(rbtn, 40, 30);
	lv_obj_add_event_cb(rbtn, rbtn_cb, LV_EVENT_CLICKED, NULL);

}

extern DMA_HandleTypeDef hdma_memtomem_dma2_stream0;
void dma_demo() {
	uint16_t color[240*32];
	uint16_t tc[3] = {0xf100, 0x7e0, 0x1f};
	uint32_t t1;
	uint16_t width=lcd_get_width();
	uint16_t height=lcd_get_height();
	int  sum=0;

	lv_obj_t* label = lv_label_create(lv_scr_act());
	lv_obj_center(label);
	lv_obj_set_style_text_font(label, &lv_font_montserrat_18, 0);
	lv_label_set_text(label, "With DMA \n    vs\n without DMA");
	lv_timer_handler();
	HAL_Delay(3000);
	lv_label_set_text(label, "Start with DMA(preload):\n10 frame\n500ms delay \nbetween frames");
	lv_timer_handler();
	HAL_Delay(3000);

	for (int i = 0; i < 10; i++) {
		//t1 = HAL_GetTick();
		for (int j = 0; j < 240*32; j++) color[j] = tc[i%3];
		t1 = HAL_GetTick();
			lcd_set_window(0, 0, width-1, height-1);

			// use memory-to-memory DMA
			for (int k=0; k < 10; k++) {
				//for (int j = 0; j < 240*32; j++) color[j] = tc[i%3];
				HAL_DMA_Start(&hdma_memtomem_dma2_stream0, (uint32_t)color, (LCD_DATA_BASE), 240*32);
				HAL_DMA_PollForTransfer(&hdma_memtomem_dma2_stream0, HAL_DMA_FULL_TRANSFER, 1000);
				}
		sum += HAL_GetTick()-t1;
		HAL_Delay(500);
	}
	lv_label_set_text_fmt(label, "End with DMA:\n10 frames \nTotal Time:%d ms", sum);
	lv_timer_handler();

	HAL_Delay(5000);
	lv_label_set_text(label, "Start without DMA:\n10 frame\n500ms delay \nbetween frames");
	lv_timer_handler();
	HAL_Delay(3000);
	sum=0;
	for (int i = 0; i < 10; i++) {

		t1 = HAL_GetTick();

		lcd_fill_RGB(tc[i%3], 0, 0, width, height);

		sum += HAL_GetTick()-t1;
		HAL_Delay(500);
	}
	lv_label_set_text_fmt(label, "End without DMA:\n10 frames \nTotal Time:%d ms", sum);
	lv_timer_handler();
	HAL_Delay(5000);
}

uint8_t test_with_dma=true;
void sd_img_dma_demo() {
	uint32_t t1;
	int sum=0;
	char fn[20];
	lv_obj_t* img = lv_img_create(lv_scr_act());
	lv_obj_center(img);
	lv_obj_t* label = lv_label_create(lv_scr_act());
	lv_obj_center(label);
	lv_obj_set_style_text_font(label, &lv_font_montserrat_18, 0);
	lv_label_set_text(label, "With DMA \n       vs\n without DMA");
	lv_timer_handler();
	HAL_Delay(3000);
	if (test_with_dma)
		lv_label_set_text(label, "Start with DMA:\n10 frame\n500ms delay \nbetween frames");
	else
		lv_label_set_text(label, "Start without DMA:\n10 frame\n500ms delay \nbetween frames");
	lv_timer_handler();
	HAL_Delay(3000);
	lv_obj_add_flag(label, LV_OBJ_FLAG_HIDDEN);
	sum=0;

	for (int i =0; i < 10; i++) {
		t1 = HAL_GetTick();
		sprintf(fn, "S:img%d.bmp", i);
		lv_img_set_src(img, fn);
		lv_timer_handler();
		sum += (HAL_GetTick()-t1);
		HAL_Delay(500);
	}

	lv_obj_add_flag(img, LV_OBJ_FLAG_HIDDEN);
	lv_obj_clear_flag(label, LV_OBJ_FLAG_HIDDEN);
	if (test_with_dma)
		lv_label_set_text_fmt(label, "End with DMA:\n10 frames \nTotal Time:%d ms", sum);
	else
		lv_label_set_text_fmt(label, "End without DMA:\n10 frames \nTotal Time:%d ms", sum);
	lv_timer_handler();
	HAL_Delay(5000);


}

lv_obj_t* temp_bar;
lv_obj_t* humi_meter;
lv_meter_indicator_t * humi_indic;
static void temp_bar_event_cb(lv_event_t * e)
{
    lv_obj_draw_part_dsc_t * dsc = lv_event_get_draw_part_dsc(e);
    if(dsc->part != LV_PART_INDICATOR) return;

    lv_obj_t * obj = lv_event_get_target(e);

    lv_draw_label_dsc_t label_dsc;
    lv_draw_label_dsc_init(&label_dsc);
    label_dsc.font = LV_FONT_DEFAULT;

    char buf[8];
    lv_snprintf(buf, sizeof(buf), "%d", (int)lv_bar_get_value(obj));

    lv_point_t txt_size;
    lv_txt_get_size(&txt_size, buf, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
                    label_dsc.flag);

    lv_area_t txt_area;
    /*If the indicator is long enough put the text inside on the right*/
    if(lv_area_get_height(dsc->draw_area) > txt_size.x + 20) {
        txt_area.x2 = dsc->draw_area->x2 - 5;
        txt_area.x1 = txt_area.x2 - txt_size.x + 1;
        label_dsc.color = lv_color_white();
    }
    /*If the indicator is still short put the text out of it on the right*/
    else {
        txt_area.x1 = dsc->draw_area->x2 + 5;
        txt_area.x2 = txt_area.x1 + txt_size.x - 1;
        label_dsc.color = lv_color_black();
    }

    txt_area.y1 = dsc->draw_area->y1 + (lv_area_get_width(dsc->draw_area) - txt_size.y) / 2;
    txt_area.y2 = txt_area.y1 + txt_size.y - 1;

    lv_draw_label(dsc->draw_ctx, &label_dsc, &txt_area, buf, NULL);
}
void temp_humi_demo () {

	// temperature
	static lv_style_t style_bg;
	static lv_style_t style_indic;

	lv_style_init(&style_bg);
	lv_style_set_border_color(&style_bg, lv_palette_main(LV_PALETTE_BLUE));
	lv_style_set_border_width(&style_bg, 2);
	lv_style_set_pad_all(&style_bg, 6); /*To make the indicator smaller*/
	lv_style_set_radius(&style_bg, 6);
	lv_style_set_anim_time(&style_bg, 1000);

	lv_style_init(&style_indic);
	lv_style_set_bg_opa(&style_indic, LV_OPA_COVER);
	lv_style_set_radius(&style_indic, 3);
	lv_style_set_bg_color(&style_indic, lv_palette_main(LV_PALETTE_RED));
	lv_style_set_bg_grad_color(&style_indic, lv_palette_main(LV_PALETTE_BLUE));
	lv_style_set_bg_grad_dir(&style_indic, LV_GRAD_DIR_VER);

	temp_bar = lv_bar_create(lv_scr_act());
	lv_obj_remove_style_all(temp_bar);  /*To have a clean start*/
	lv_obj_add_style(temp_bar, &style_bg, 0);
	lv_obj_add_style(temp_bar, &style_indic, LV_PART_INDICATOR);
	lv_bar_set_range(temp_bar, -10, 70);
	lv_obj_add_event_cb(temp_bar, temp_bar_event_cb, LV_EVENT_DRAW_PART_END, NULL);

	lv_obj_set_size(temp_bar, 40, 180);
	lv_obj_align(temp_bar, LV_ALIGN_TOP_LEFT,15,10);

	lv_obj_t* temp_label=lv_label_create(lv_scr_act());
	lv_obj_set_style_text_font(temp_label, &lv_font_montserrat_18, 0);
	lv_obj_set_style_text_color(temp_label, lv_palette_main(LV_PALETTE_BLUE), 0);
	lv_obj_set_size(temp_label, 30, 30);
	char tempbuff[10];
	sprintf(tempbuff, "\xC2\xB0" "C"); //°C
	lv_label_set_text(temp_label, tempbuff);
	lv_obj_align_to(temp_label, temp_bar, LV_ALIGN_OUT_BOTTOM_MID, 0, 5);

	lv_bar_set_value(temp_bar, 70, LV_ANIM_ON);


	//humidity
	humi_meter = lv_meter_create(lv_scr_act());
	lv_obj_align(humi_meter, LV_ALIGN_TOP_RIGHT, -10, 10);
	lv_obj_set_size(humi_meter, 200, 200);

	lv_obj_remove_style(humi_meter, NULL, LV_PART_INDICATOR);

	lv_meter_scale_t * scale = lv_meter_add_scale(humi_meter);
	lv_meter_set_scale_ticks(humi_meter, scale, 11, 2, 10, lv_palette_main(LV_PALETTE_GREY));
	lv_meter_set_scale_major_ticks(humi_meter, scale, 1, 2, 15, lv_color_hex3(0xeee), 5);
	lv_meter_set_scale_range(humi_meter, scale, 0, 100, 270, 135);


	humi_indic = lv_meter_add_arc(humi_meter, scale, 10, lv_palette_main(LV_PALETTE_GREEN), 0);
	lv_meter_set_indicator_end_value(humi_meter, humi_indic, 100);
	lv_obj_t* humi_label=lv_label_create(lv_scr_act());
	lv_obj_set_size(humi_label, 30, 30);
	lv_obj_set_style_text_font(humi_label, &lv_font_montserrat_18, 0);
	lv_obj_set_style_text_color(humi_label, lv_palette_main(LV_PALETTE_BLUE), 0);
	lv_label_set_text(humi_label, "%");
	lv_obj_align_to(humi_label, humi_meter, LV_ALIGN_BOTTOM_MID, 0,5);
}

• STM32_LVGL.ioc

#MicroXplorer Configuration settings - do not modify
CAD.formats=
CAD.pinconfig=
CAD.provider=
Dma.MEMTOMEM.0.Direction=DMA_MEMORY_TO_MEMORY
Dma.MEMTOMEM.0.FIFOMode=DMA_FIFOMODE_ENABLE
Dma.MEMTOMEM.0.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
Dma.MEMTOMEM.0.Instance=DMA2_Stream0
Dma.MEMTOMEM.0.MemBurst=DMA_MBURST_SINGLE
Dma.MEMTOMEM.0.MemDataAlignment=DMA_MDATAALIGN_HALFWORD
Dma.MEMTOMEM.0.MemInc=DMA_MINC_DISABLE
Dma.MEMTOMEM.0.Mode=DMA_NORMAL
Dma.MEMTOMEM.0.PeriphBurst=DMA_PBURST_SINGLE
Dma.MEMTOMEM.0.PeriphDataAlignment=DMA_PDATAALIGN_HALFWORD
Dma.MEMTOMEM.0.PeriphInc=DMA_PINC_ENABLE
Dma.MEMTOMEM.0.Priority=DMA_PRIORITY_LOW
Dma.MEMTOMEM.0.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
Dma.Request0=MEMTOMEM
Dma.Request1=SDIO_RX
Dma.Request2=SDIO_TX
Dma.RequestsNb=3
Dma.SDIO_RX.1.Direction=DMA_PERIPH_TO_MEMORY
Dma.SDIO_RX.1.FIFOMode=DMA_FIFOMODE_ENABLE
Dma.SDIO_RX.1.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
Dma.SDIO_RX.1.Instance=DMA2_Stream3
Dma.SDIO_RX.1.MemBurst=DMA_MBURST_INC4
Dma.SDIO_RX.1.MemDataAlignment=DMA_MDATAALIGN_WORD
Dma.SDIO_RX.1.MemInc=DMA_MINC_ENABLE
Dma.SDIO_RX.1.Mode=DMA_PFCTRL
Dma.SDIO_RX.1.PeriphBurst=DMA_PBURST_INC4
Dma.SDIO_RX.1.PeriphDataAlignment=DMA_PDATAALIGN_WORD
Dma.SDIO_RX.1.PeriphInc=DMA_PINC_DISABLE
Dma.SDIO_RX.1.Priority=DMA_PRIORITY_LOW
Dma.SDIO_RX.1.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
Dma.SDIO_TX.2.Direction=DMA_MEMORY_TO_PERIPH
Dma.SDIO_TX.2.FIFOMode=DMA_FIFOMODE_ENABLE
Dma.SDIO_TX.2.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL
Dma.SDIO_TX.2.Instance=DMA2_Stream6
Dma.SDIO_TX.2.MemBurst=DMA_MBURST_INC4
Dma.SDIO_TX.2.MemDataAlignment=DMA_MDATAALIGN_WORD
Dma.SDIO_TX.2.MemInc=DMA_MINC_ENABLE
Dma.SDIO_TX.2.Mode=DMA_PFCTRL
Dma.SDIO_TX.2.PeriphBurst=DMA_PBURST_INC4
Dma.SDIO_TX.2.PeriphDataAlignment=DMA_PDATAALIGN_WORD
Dma.SDIO_TX.2.PeriphInc=DMA_PINC_DISABLE
Dma.SDIO_TX.2.Priority=DMA_PRIORITY_LOW
Dma.SDIO_TX.2.RequestParameters=Instance,Direction,PeriphInc,MemInc,PeriphDataAlignment,MemDataAlignment,Mode,Priority,FIFOMode,FIFOThreshold,MemBurst,PeriphBurst
FATFS.BSP.number=1
FATFS.IPParameters=USE_DMA_CODE_SD,_MAX_SS
FATFS.USE_DMA_CODE_SD=1
FATFS._MAX_SS=4096
FATFS0.BSP.STBoard=false
FATFS0.BSP.api=Unknown
FATFS0.BSP.component=
FATFS0.BSP.condition=
FATFS0.BSP.instance=PC4
FATFS0.BSP.ip=GPIO
FATFS0.BSP.mode=Input
FATFS0.BSP.name=Detect_SDIO
FATFS0.BSP.semaphore=
FATFS0.BSP.solution=PC4
FSMC.AddressSetupTime1=6
FSMC.BusTurnAroundDuration1=4
FSMC.DataSetupTime1=4
FSMC.IPParameters=DataSetupTime1,BusTurnAroundDuration1,AddressSetupTime1
File.Version=6
I2C1.I2C_Mode=I2C_Fast
I2C1.IPParameters=I2C_Mode
KeepUserPlacement=false
Mcu.CPN=STM32F407VET6
Mcu.Family=STM32F4
Mcu.IP0=DMA
Mcu.IP1=FATFS
Mcu.IP2=FSMC
Mcu.IP3=I2C1
Mcu.IP4=NVIC
Mcu.IP5=RCC
Mcu.IP6=SDIO
Mcu.IP7=SPI2
Mcu.IP8=SYS
Mcu.IP9=TIM3
Mcu.IPNb=10
Mcu.Name=STM32F407V(E-G)Tx
Mcu.Package=LQFP100
Mcu.Pin0=PC14-OSC32_IN
Mcu.Pin1=PC15-OSC32_OUT
Mcu.Pin10=PE10
Mcu.Pin11=PE11
Mcu.Pin12=PE12
Mcu.Pin13=PE13
Mcu.Pin14=PE14
Mcu.Pin15=PE15
Mcu.Pin16=PB12
Mcu.Pin17=PB13
Mcu.Pin18=PB14
Mcu.Pin19=PB15
Mcu.Pin2=PH0-OSC_IN
Mcu.Pin20=PD8
Mcu.Pin21=PD9
Mcu.Pin22=PD10
Mcu.Pin23=PD13
Mcu.Pin24=PD14
Mcu.Pin25=PD15
Mcu.Pin26=PC8
Mcu.Pin27=PC9
Mcu.Pin28=PC10
Mcu.Pin29=PC11
Mcu.Pin3=PH1-OSC_OUT
Mcu.Pin30=PC12
Mcu.Pin31=PD0
Mcu.Pin32=PD1
Mcu.Pin33=PD2
Mcu.Pin34=PD4
Mcu.Pin35=PD5
Mcu.Pin36=PD7
Mcu.Pin37=PB6
Mcu.Pin38=PB7
Mcu.Pin39=VP_FATFS_VS_SDIO
Mcu.Pin4=PC4
Mcu.Pin40=VP_SYS_VS_Systick
Mcu.Pin41=VP_TIM3_VS_ClockSourceINT
Mcu.Pin5=PC5
Mcu.Pin6=PB1
Mcu.Pin7=PE7
Mcu.Pin8=PE8
Mcu.Pin9=PE9
Mcu.PinsNb=42
Mcu.ThirdPartyNb=0
Mcu.UserConstants=
Mcu.UserName=STM32F407VETx
MxCube.Version=6.12.0
MxDb.Version=DB.6.0.120
NVIC.BusFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.DMA2_Stream3_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:true
NVIC.DMA2_Stream6_IRQn=true\:0\:0\:false\:false\:true\:false\:true\:true
NVIC.DebugMonitor_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.ForceEnableDMAVector=true
NVIC.HardFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.MemoryManagement_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.NonMaskableInt_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.PendSV_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.PriorityGroup=NVIC_PRIORITYGROUP_4
NVIC.SDIO_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
NVIC.SysTick_IRQn=true\:15\:0\:false\:false\:true\:false\:true\:false
NVIC.TIM3_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:true
NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:false\:false\:false
PB1.GPIOParameters=PinState,GPIO_Label
PB1.GPIO_Label=LCD_BL
PB1.Locked=true
PB1.PinState=GPIO_PIN_SET
PB1.Signal=GPIO_Output
PB12.GPIOParameters=GPIO_Label
PB12.GPIO_Label=T_CS
PB12.Locked=true
PB12.Signal=GPIO_Output
PB13.Locked=true
PB13.Mode=Full_Duplex_Master
PB13.Signal=SPI2_SCK
PB14.Locked=true
PB14.Mode=Full_Duplex_Master
PB14.Signal=SPI2_MISO
PB15.Locked=true
PB15.Mode=Full_Duplex_Master
PB15.Signal=SPI2_MOSI
PB6.Mode=I2C
PB6.Signal=I2C1_SCL
PB7.Mode=I2C
PB7.Signal=I2C1_SDA
PC10.Mode=SD_4_bits_Wide_bus
PC10.Signal=SDIO_D2
PC11.Mode=SD_4_bits_Wide_bus
PC11.Signal=SDIO_D3
PC12.Mode=SD_4_bits_Wide_bus
PC12.Signal=SDIO_CK
PC14-OSC32_IN.Mode=LSE-External-Oscillator
PC14-OSC32_IN.Signal=RCC_OSC32_IN
PC15-OSC32_OUT.Mode=LSE-External-Oscillator
PC15-OSC32_OUT.Signal=RCC_OSC32_OUT
PC4.Locked=true
PC4.Signal=GPIO_Input
PC5.GPIOParameters=GPIO_Label
PC5.GPIO_Label=T_IRQ
PC5.Locked=true
PC5.Signal=GPIO_Input
PC8.Mode=SD_4_bits_Wide_bus
PC8.Signal=SDIO_D0
PC9.Mode=SD_4_bits_Wide_bus
PC9.Signal=SDIO_D1
PD0.Mode=16b-d1
PD0.Signal=FSMC_D2
PD1.Mode=16b-d1
PD1.Signal=FSMC_D3
PD10.Mode=16b-d1
PD10.Signal=FSMC_D15
PD13.Mode=A18_1
PD13.Signal=FSMC_A18
PD14.Mode=16b-d1
PD14.Signal=FSMC_D0
PD15.Mode=16b-d1
PD15.Signal=FSMC_D1
PD2.Mode=SD_4_bits_Wide_bus
PD2.Signal=SDIO_CMD
PD4.Mode=Lcd1
PD4.Signal=FSMC_NOE
PD5.Mode=Lcd1
PD5.Signal=FSMC_NWE
PD7.Mode=NorPsramChipSelect1_1
PD7.Signal=FSMC_NE1
PD8.Mode=16b-d1
PD8.Signal=FSMC_D13
PD9.Mode=16b-d1
PD9.Signal=FSMC_D14
PE10.Mode=16b-d1
PE10.Signal=FSMC_D7
PE11.Mode=16b-d1
PE11.Signal=FSMC_D8
PE12.Mode=16b-d1
PE12.Signal=FSMC_D9
PE13.Mode=16b-d1
PE13.Signal=FSMC_D10
PE14.Mode=16b-d1
PE14.Signal=FSMC_D11
PE15.Mode=16b-d1
PE15.Signal=FSMC_D12
PE7.Mode=16b-d1
PE7.Signal=FSMC_D4
PE8.Mode=16b-d1
PE8.Signal=FSMC_D5
PE9.Mode=16b-d1
PE9.Signal=FSMC_D6
PH0-OSC_IN.Mode=HSE-External-Oscillator
PH0-OSC_IN.Signal=RCC_OSC_IN
PH1-OSC_OUT.Mode=HSE-External-Oscillator
PH1-OSC_OUT.Signal=RCC_OSC_OUT
PinOutPanel.RotationAngle=0
ProjectManager.AskForMigrate=true
ProjectManager.BackupPrevious=false
ProjectManager.CompilerOptimize=6
ProjectManager.ComputerToolchain=false
ProjectManager.CoupleFile=false
ProjectManager.CustomerFirmwarePackage=
ProjectManager.DefaultFWLocation=true
ProjectManager.DeletePrevious=true
ProjectManager.DeviceId=STM32F407VETx
ProjectManager.FirmwarePackage=STM32Cube FW_F4 V1.28.0
ProjectManager.FreePins=false
ProjectManager.HalAssertFull=false
ProjectManager.HeapSize=0x200
ProjectManager.KeepUserCode=true
ProjectManager.LastFirmware=true
ProjectManager.LibraryCopy=1
ProjectManager.MainLocation=Core/Src
ProjectManager.NoMain=false
ProjectManager.PreviousToolchain=
ProjectManager.ProjectBuild=false
ProjectManager.ProjectFileName=STM32_LVGL.ioc
ProjectManager.ProjectName=STM32_LVGL
ProjectManager.ProjectStructure=
ProjectManager.RegisterCallBack=
ProjectManager.StackSize=0x400
ProjectManager.TargetToolchain=STM32CubeIDE
ProjectManager.ToolChainLocation=
ProjectManager.UAScriptAfterPath=
ProjectManager.UAScriptBeforePath=
ProjectManager.UnderRoot=true
ProjectManager.functionlistsort=1-SystemClock_Config-RCC-false-HAL-false,2-MX_GPIO_Init-GPIO-false-HAL-true,3-MX_DMA_Init-DMA-false-HAL-true,4-MX_FSMC_Init-FSMC-false-HAL-true,5-MX_SPI2_Init-SPI2-false-HAL-true,6-MX_TIM3_Init-TIM3-false-HAL-true,7-MX_I2C1_Init-I2C1-false-HAL-true,8-MX_SDIO_SD_Init-SDIO-false-HAL-true,9-MX_FATFS_Init-FATFS-false-HAL-false
RCC.48MHZClocksFreq_Value=48000000
RCC.AHBFreq_Value=168000000
RCC.APB1CLKDivider=RCC_HCLK_DIV4
RCC.APB1Freq_Value=42000000
RCC.APB1TimFreq_Value=84000000
RCC.APB2CLKDivider=RCC_HCLK_DIV2
RCC.APB2Freq_Value=84000000
RCC.APB2TimFreq_Value=168000000
RCC.CortexFreq_Value=168000000
RCC.EthernetFreq_Value=168000000
RCC.FCLKCortexFreq_Value=168000000
RCC.FamilyName=M
RCC.HCLKFreq_Value=168000000
RCC.HSE_VALUE=8000000
RCC.HSI_VALUE=16000000
RCC.I2SClocksFreq_Value=192000000
RCC.IPParameters=48MHZClocksFreq_Value,AHBFreq_Value,APB1CLKDivider,APB1Freq_Value,APB1TimFreq_Value,APB2CLKDivider,APB2Freq_Value,APB2TimFreq_Value,CortexFreq_Value,EthernetFreq_Value,FCLKCortexFreq_Value,FamilyName,HCLKFreq_Value,HSE_VALUE,HSI_VALUE,I2SClocksFreq_Value,LSI_VALUE,MCO2PinFreq_Value,PLLCLKFreq_Value,PLLM,PLLN,PLLQ,PLLQCLKFreq_Value,RTCFreq_Value,RTCHSEDivFreq_Value,SYSCLKFreq_VALUE,SYSCLKSource,VCOI2SOutputFreq_Value,VCOInputFreq_Value,VCOOutputFreq_Value,VcooutputI2S
RCC.LSI_VALUE=32000
RCC.MCO2PinFreq_Value=168000000
RCC.PLLCLKFreq_Value=168000000
RCC.PLLM=8
RCC.PLLN=168
RCC.PLLQ=7
RCC.PLLQCLKFreq_Value=48000000
RCC.RTCFreq_Value=32000
RCC.RTCHSEDivFreq_Value=4000000
RCC.SYSCLKFreq_VALUE=168000000
RCC.SYSCLKSource=RCC_SYSCLKSOURCE_PLLCLK
RCC.VCOI2SOutputFreq_Value=384000000
RCC.VCOInputFreq_Value=2000000
RCC.VCOOutputFreq_Value=336000000
RCC.VcooutputI2S=192000000
SPI2.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_32
SPI2.CalculateBaudRate=1.3125 MBits/s
SPI2.Direction=SPI_DIRECTION_2LINES
SPI2.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate,BaudRatePrescaler
SPI2.Mode=SPI_MODE_MASTER
SPI2.VirtualType=VM_MASTER
TIM3.AutoReloadPreload=TIM_AUTORELOAD_PRELOAD_ENABLE
TIM3.IPParameters=Prescaler,Period,AutoReloadPreload,TIM_MasterOutputTrigger
TIM3.Period=10-1
TIM3.Prescaler=42000-1
TIM3.TIM_MasterOutputTrigger=TIM_TRGO_RESET
VP_FATFS_VS_SDIO.Mode=SDIO
VP_FATFS_VS_SDIO.Signal=FATFS_VS_SDIO
VP_SYS_VS_Systick.Mode=SysTick
VP_SYS_VS_Systick.Signal=SYS_VS_Systick
VP_TIM3_VS_ClockSourceINT.Mode=Internal
VP_TIM3_VS_ClockSourceINT.Signal=TIM3_VS_ClockSourceINT
board=custom
isbadioc=false

[Raspberry Pi Pico W] A tiny but fully functional BLE Bluetooth keyboard using LVGL and Btstack libraries | |包含注音輸入鍵盤

 本篇文章介紹如何利用Raspberry Pi Pico W和LVGL Graphics library 與 Btstack bluetooth library，製做一個小型但又功能齊全的BLE藍芽鍵盤。

有關HID over GATT device的介紹，可參閱前篇：[Raspberry Pi Pico W] BTstack BLE Ep 4. HID over GATT -- Custom keypad HID device, 本篇文章著重在利用LVGL library製作完整功能的鍵盤。

本文章介紹的鍵盤分別有四縱模式: 小寫英文字、大寫英文字、數字與特殊符號和注音鍵盤。四種鍵盤分對應到LVGL keyboard widget: LV_KEYBOARD_MODE_TEXT_LOWER、LV_KEYBOARD_MODE_TEXT_UPPER、LV_KEYBOARD_MODE_SPECIAL and LV_KEYBOARD_MODE_USER_1。

小寫英文字、大寫英文字、數字與特殊符號鍵盤使用LVGL內定keyboard widgets。

注音輸入鍵盤則利用LV_KEYBOARD_MODE_USER_1模式，自製鍵盤時需要按鍵排例方式與每個按鍵控制模式：

• 按鍵排例方式

• 每個按鍵控制模式

使用

lv_obj_set_style_text_font(kb, &jf_font, LV_PART_ITEMS);//設定字形

lv_keyboard_set_map(kb, LV_KEYBOARD_MODE_USER_1, font_map, font_ctl_map);//設定LV_KEYBOARD_MODE_USER_1鍵盤

• 注音鍵盤HID scan code對應表：

製作鍵盤按鍵對應到HID scan code, 其中modifier為0。

lv_obj_add_event_cb(lvgl_keyboard, lvgl_keyboard_cb, LV_EVENT_ALL, lvgl_keyboard);

使用上述指令加入按鍵的event callback function，處理收到按鍵按下時查詢按鍵的modifier and key_code 再透過HID report由藍芽輸出。其HID report格式如下所定義：

hid keyboard descriptor定義input data為：modifier(1 byte), reserved byte(1 byte)與keycode(6 bytes)。output data為:5 bits+3 bits。

指令：

send_hid_spec_code(uint8_t modifier, uint8_t keycode);

直接送出HID report,

key_input(uint8_t character);

查詢輸入character的modifier與keycode後再送出HID Report。

static int keycode_and_modifer_us_for_character(uint8_t character, uint8_t * keycode, uint8_t * modifier); //查詢character的modifier and keycode

三種keycode表如下：

• static const uint8_t keytable_scan_codes[]:
  小寫字母與沒有shift的特殊符號。
• static const uint8_t keytable_scan_codes_shift[]:
  大寫字母與有shift的特殊符號。
• static const char* keyboard_phonetic[]:
  注音符號keycode表，modifier為0。

詳細程式碼附於文章末尾。

成果影片：

程式碼：

pico_lvgl library: 
如何移植LVGL library到Raspberry Pi Pico，請參閱前篇文章介紹。

CMakeLists.txt

# Generated Cmake Pico project file

cmake_minimum_required(VERSION 3.13)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

# Initialise pico_sdk from installed location
# (note this can come from environment, CMake cache etc)
set(PICO_SDK_PATH "/home/duser/pico/pico-sdk")

set(PICO_BOARD pico_w CACHE STRING "Board type")

# Pull in Raspberry Pi Pico SDK (must be before project)
include(pico_sdk_import.cmake)

if (PICO_SDK_VERSION_STRING VERSION_LESS "1.4.0")
  message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.4.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}")
endif()

project(picow_lvgl_hog_keyboard C CXX ASM)

# Initialise the Raspberry Pi Pico SDK
pico_sdk_init()

# Add executable. Default name is the project name, version 0.1

add_executable(picow_lvgl_hog_keyboard 
                picow_lvgl_hog_keyboard.c
                lvgl_keyboard.c
                zh_TW_kb.c
                shortcuts.c
)

pico_set_program_name(picow_lvgl_hog_keyboard "picow_lvgl_bt_kb")
pico_set_program_version(picow_lvgl_hog_keyboard "0.1")

pico_enable_stdio_uart(picow_lvgl_hog_keyboard 1)
pico_enable_stdio_usb(picow_lvgl_hog_keyboard 0)

# Add the standard library to the build
target_link_libraries(picow_lvgl_hog_keyboard
        pico_stdlib)

# Add the standard include files to the build
target_include_directories(picow_lvgl_hog_keyboard PRIVATE
  ${CMAKE_CURRENT_LIST_DIR}
  ${CMAKE_CURRENT_LIST_DIR}/.. # for our common lwipopts or any other standard includes, if required
)

# Add any user requested libraries
target_link_libraries(picow_lvgl_hog_keyboard 
        hardware_spi
        hardware_dma
        hardware_pio
        pico_util
        pico_cyw43_arch_none
        pico_btstack_cyw43
        pico_btstack_ble
        )

add_subdirectory(pico_lvgl)

target_link_libraries(picow_lvgl_hog_keyboard
        pico_lvgl
)
pico_btstack_make_gatt_header(picow_lvgl_hog_keyboard PRIVATE "${CMAKE_CURRENT_LIST_DIR}/picow_lvgl_hog_keyboard.gatt")

pico_add_extra_outputs(picow_lvgl_hog_keyboard)

lvgl_keyboard.c

#include "stdio.h"
#include "pico/stdlib.h"
#include "pico_lvgl.h"
#include "usb_hid_scan_code.h"

extern const lv_font_t jf_font;

uint8_t lvgl_kb_left[4] = {239, 129, 147,0};
uint8_t lvgl_kb_right[4] = {239, 129, 148,0};
uint8_t lvgl_kb_ok[4] = {239, 128, 140,0};
uint8_t lvgl_kb_enter[4] = {239, 162, 162,0};
uint8_t lvgl_kb_bs[4] = {239, 149, 154,0};
uint8_t lvgl_kb_kb[4] = {239, 132, 156,0};


void set_zh_TW_keyboard(lv_obj_t *kb);
void shortcuts_init(lv_obj_t* parent);
void key_input(char character);
void send_hid_spec_code(uint8_t modifier, uint8_t keycode);


static uint8_t phonetic_selected=0;
void toggle_sel_key(lv_obj_t* kb) {

            if (phonetic_selected==0)  {
                phonetic_selected = 1;
                send_hid_spec_code(0, KEY_DOWN);
                for(int i=0; i < 10; i++) {
                    lv_btnmatrix_clear_btn_ctrl(kb,i,LV_BTNMATRIX_CTRL_HIDDEN);
                    lv_btnmatrix_set_btn_ctrl(kb,i, LV_KEYBOARD_CTRL_BTN_FLAGS|1);
                }
            }
            else{
                if (phonetic_selected == 1) {
                    send_hid_spec_code(0, KEY_UP);
                }
                for(int i=0; i < 10; i++) {
                    lv_btnmatrix_clear_btn_ctrl(kb,i,LV_KEYBOARD_CTRL_BTN_FLAGS|1);
                    lv_btnmatrix_set_btn_ctrl(kb,i, LV_BTNMATRIX_CTRL_HIDDEN);
                } 
                phonetic_selected=0;
            }
                
            
}
static bool lookup_phonetic_keycode(lv_obj_t *kb, uint8_t* key,  uint8_t * keycode){
    uint16_t size = 57;//sizeof(keyboard_phonetic);

    int i;
    for (i=0;i<size;i++){
        if (strcmp(keyboard_phonetic[i], key) !=0) continue;
        *keycode = i;
        return true;
    }
    if (key[0] >= '0' && key[0] <= '9'){
        key_input(key[0]);
        phonetic_selected++;
        toggle_sel_key(kb);
        
    }
    return false;
}

uint8_t lvgl_keyboard_mode;
void lvgl_keyboard_cb(lv_event_t* e) {
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t* obj = lv_event_get_target(e);
    lv_obj_t * kb = lv_event_get_user_data(e);
    char key[5];
    if (code == LV_EVENT_CLICKED) {
        strcpy(key, lv_keyboard_get_btn_text(kb,lv_keyboard_get_selected_btn(kb)));
        if (strcmp(key, "ABC")==0) {
            lvgl_keyboard_mode = LV_KEYBOARD_MODE_TEXT_UPPER;
            return;
        } 
        if (strcmp(key, "abc") == 0) {
            lvgl_keyboard_mode = LV_KEYBOARD_MODE_TEXT_LOWER;
            return;
        }
        if (lv_keyboard_get_mode(kb) != LV_KEYBOARD_MODE_USER_1) {
            if ((lvgl_keyboard_mode == LV_KEYBOARD_MODE_TEXT_LOWER || lvgl_keyboard_mode == LV_KEYBOARD_MODE_TEXT_UPPER ) && 
                key[0] == '1') {
                lvgl_keyboard_mode = LV_KEYBOARD_MODE_SPECIAL;
                return;
            }
            if (strlen(key) == 1) {
                key_input(key[0]);
                return;
            }
        } else {
            static uint8_t keycode;
            if (lookup_phonetic_keycode(kb, key, &keycode)) {
                send_hid_spec_code(0, keycode);
                return;
            }
        }
        if (strcmp(key, lvgl_kb_enter)==0) {
            key_input(CHAR_RETURN);
            return;
        }
        if (strcmp(key, lvgl_kb_right)==0 || strcmp(key, "〉") == 0) {
            send_hid_spec_code(0, KEY_RIGHT);
            return;
        }
        if (strcmp(key, lvgl_kb_left)==0 || strcmp(key, "〈") == 0) {
            send_hid_spec_code(0, KEY_LEFT);
            return;
            }
        if (strcmp(key, lvgl_kb_bs)==0 || strcmp(key, "←")==0) {
            key_input(CHAR_BACKSPACE);
            return;
        }
        if (strcmp(key, "︿") == 0) {
            send_hid_spec_code(0, KEY_UP);
            return;
        }
        if (strcmp(key, "﹀") == 0) {
            send_hid_spec_code(0, KEY_DOWN);
            return;
        }
        if (strcmp(key, "，") == 0) {
            //for Windows
            //send_hid_spec_code(0, KEY_GRAVE);send_hid_spec_code(0, KEY_COMMA); 
            send_hid_spec_code(KEY_MOD_LSHIFT, KEY_COMMA);
            return;
        }
        if (strcmp(key, "。") == 0) {
            ///for Windows
            //send_hid_spec_code(0, KEY_GRAVE);send_hid_spec_code(0, KEY_DOT); 
            send_hid_spec_code(KEY_MOD_LSHIFT, KEY_DOT);
            return;
        }
        if (strcmp(key, lvgl_kb_ok)==0) {
            key_input(CHAR_RETURN);
            return;
        }
        if (strcmp(key, lvgl_kb_kb)==0){
            lv_obj_set_style_text_font(kb, &jf_font, LV_PART_ITEMS);
            lv_keyboard_set_mode(kb, LV_KEYBOARD_MODE_USER_1);
            send_hid_spec_code(KEY_MOD_LCTRL, 0x2c); //0x2c space key scan code;  
            return;              
        } 
        if (strcmp(key, "英")==0){
            lv_obj_set_style_text_font(kb, lv_font_default(), LV_PART_ITEMS);
            lv_keyboard_set_mode(kb, LV_KEYBOARD_MODE_TEXT_LOWER);
            send_hid_spec_code(KEY_MOD_LCTRL, 0x2c); //0x2c space key scan code;  
            return;
        } 
        if (strcmp(key, "數")==0){
            lv_obj_set_style_text_font(kb, lv_font_default(), LV_PART_ITEMS);
            lv_keyboard_set_mode(kb, LV_KEYBOARD_MODE_SPECIAL);
            send_hid_spec_code(KEY_MOD_LCTRL, 0x2c); //0x2c space key scan code;       
            return;       
        } 
        if (strcmp(key, "選字")==0){
            toggle_sel_key(kb);
            return;       
        }
    } 
}

void lvgl_keyboard_init(void)
{
    /*Create a keyboard to use it with an of the text areas*/
    lv_obj_t * lvgl_keyboard = lv_keyboard_create(lv_scr_act());

    lv_obj_t *shortcuts_frame = lv_obj_create(lv_scr_act());
    shortcuts_init(shortcuts_frame);
    lv_obj_set_size(shortcuts_frame, lv_pct(100), lv_pct(32));
    lv_obj_set_style_pad_all(shortcuts_frame, 3,0);
    lv_obj_set_style_bg_color(shortcuts_frame, lv_palette_main(LV_PALETTE_LIGHT_BLUE),0);

    set_zh_TW_keyboard(lvgl_keyboard);
    
    lvgl_keyboard_mode = LV_KEYBOARD_MODE_TEXT_LOWER;
    lv_obj_set_size(lvgl_keyboard, lv_pct(100), lv_pct(67));

    lv_obj_add_event_cb(lvgl_keyboard, lvgl_keyboard_cb, LV_EVENT_ALL, lvgl_keyboard);
}

pico_lvgl_hog_keyboard.c

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "btstack.h"

#include "ble/gatt-service/battery_service_server.h"
#include "ble/gatt-service/device_information_service_server.h"
#include "ble/gatt-service/hids_device.h"

#include "picow_lvgl_hog_keyboard.h"
#include "inttypes.h"
#include "pico_lvgl.h"

#include "usb_hid_scan_code.h"

extern const lv_font_t jf_font;


PIO TFT_PIO = pio0;
#define TFT_SM 0
#define TFT_SDI_GPIO 9
#define TFT_CSX_DCX_SCK_GPIO 6 // CSX=8, DCX=7, SCK=6, SIDE_SET

void lvgl_keyboard_init();

static btstack_packet_callback_registration_t hci_event_callback_registration;
static btstack_packet_callback_registration_t sm_event_callback_registration;
static uint8_t battery = 100;
static hci_con_handle_t con_handle = HCI_CON_HANDLE_INVALID;
static uint8_t protocol_mode = HID_PROTOCOL_MODE_REPORT;

const uint8_t adv_data[] = {
    // Flags general discoverable, BR/EDR not supported
    0x02, BLUETOOTH_DATA_TYPE_FLAGS, 0x06,
    // Name
    0x0d, BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME, 'H', 'I', 'D', ' ', 'K', 'e', 'y', 'b', 'o', 'a', 'r', 'd',
    //0x0d
    // 16-bit Service UUIDs
    0x03, BLUETOOTH_DATA_TYPE_COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS, 
                ORG_BLUETOOTH_SERVICE_HUMAN_INTERFACE_DEVICE & 0xff, ORG_BLUETOOTH_SERVICE_HUMAN_INTERFACE_DEVICE >> 8,
    // Appearance HID - Keyboard (Category 15, Sub-Category 1)
    0x03, BLUETOOTH_DATA_TYPE_APPEARANCE, 0xC1, 0x03,
};
const uint8_t adv_data_len = sizeof(adv_data);

// Buffer for 30 characters
static uint8_t key_input_storage[30];
static btstack_ring_buffer_t key_input_buffer;

// HID Keyboard lookup
static int lookup_keycode(uint8_t character, const uint8_t * table, int size, uint8_t * keycode){
    int i;
    for (i=0;i<size;i++){
        if (table[i] != character) continue;
        *keycode = i;
        return 1;
    }
    return 0;
}

static int keycode_and_modifer_us_for_character(uint8_t character, uint8_t * keycode, uint8_t * modifier){
    int found;
    found = lookup_keycode(character, keytable_scan_codes, sizeof(keytable_scan_codes), keycode);
    if (found) {
        *modifier = 0;  // none
        return 1;
    }
    found = lookup_keycode(character, keytable_scan_codes_shift, sizeof(keytable_scan_codes_shift), keycode);
    if (found) {
        *modifier = 2;  // shift
        return 1;
    }
    return 0;
}

// HID Report sending
static void send_report(int modifier, int keycode){
    uint8_t report[] = {  modifier, 0, keycode, 0, 0, 0, 0, 0};
    switch (protocol_mode){
        case 0:
            hids_device_send_boot_keyboard_input_report(con_handle, report, sizeof(report));
            break;
        case 1:
           hids_device_send_input_report(con_handle, report, sizeof(report));
           break;
        default:
            break;
    }
}

static enum {
    W4_INPUT,
    W4_CAN_SEND_FROM_BUFFER,
    W4_CAN_SEND_KEY_UP,
} state;


static void typing_can_send_now(void){
    switch (state){
        case W4_CAN_SEND_FROM_BUFFER:
            while (1){
                uint8_t c;
                uint32_t num_bytes_read;

                btstack_ring_buffer_read(&key_input_buffer, &c, 1, &num_bytes_read);
                if (num_bytes_read == 0){
                    state = W4_INPUT;
                    break;
                }

                uint8_t modifier;
                uint8_t keycode;
                int found = keycode_and_modifer_us_for_character(c, &keycode, &modifier);
                if (!found) continue;

                printf("sending: %c\n", c);

                send_report(modifier, keycode);
                state = W4_CAN_SEND_KEY_UP;
                hids_device_request_can_send_now_event(con_handle);
                break;
            }
            break;
        case W4_CAN_SEND_KEY_UP:
            send_report(0, 0);
            if (btstack_ring_buffer_bytes_available(&key_input_buffer)){
                state = W4_CAN_SEND_FROM_BUFFER;
                hids_device_request_can_send_now_event(con_handle);
            } else {
                state = W4_INPUT;
            }
            break;
        default:
            break;
    }
}

void send_hid_spec_code(uint8_t modifier, uint8_t keycode) {
    send_report(modifier, keycode);
    state = W4_CAN_SEND_KEY_UP;
    hids_device_request_can_send_now_event(con_handle);
}

void key_input(char character){
    uint8_t c = character;
    btstack_ring_buffer_write(&key_input_buffer, &c, 1);
    // start sending
    if (state == W4_INPUT && con_handle != HCI_CON_HANDLE_INVALID){
        state = W4_CAN_SEND_FROM_BUFFER;
        hids_device_request_can_send_now_event(con_handle);
    }
}

static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
    UNUSED(channel);
    UNUSED(size);

    if (packet_type != HCI_EVENT_PACKET) return;

    switch (hci_event_packet_get_type(packet)) {
        case HCI_EVENT_DISCONNECTION_COMPLETE:
            con_handle = HCI_CON_HANDLE_INVALID;
            printf("Disconnected\n");
            break;
        case SM_EVENT_JUST_WORKS_REQUEST:
            printf("Just Works requested\n");
            sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
            break;
        case SM_EVENT_NUMERIC_COMPARISON_REQUEST:
            printf("Confirming numeric comparison: %"PRIu32"\n", sm_event_numeric_comparison_request_get_passkey(packet));
            sm_numeric_comparison_confirm(sm_event_passkey_display_number_get_handle(packet));
            break;
        case SM_EVENT_PASSKEY_DISPLAY_NUMBER:
            printf("Display Passkey: %"PRIu32"\n", sm_event_passkey_display_number_get_passkey(packet));
            break;
        case HCI_EVENT_HIDS_META:
            switch (hci_event_hids_meta_get_subevent_code(packet)){
                case HIDS_SUBEVENT_INPUT_REPORT_ENABLE:
                    con_handle = hids_subevent_input_report_enable_get_con_handle(packet);
                    printf("Report Characteristic Subscribed %u\n", hids_subevent_input_report_enable_get_enable(packet));
                    break;
                case HIDS_SUBEVENT_BOOT_KEYBOARD_INPUT_REPORT_ENABLE:
                    con_handle = hids_subevent_boot_keyboard_input_report_enable_get_con_handle(packet);
                    printf("Boot Keyboard Characteristic Subscribed %u\n", hids_subevent_boot_keyboard_input_report_enable_get_enable(packet));
                    break;
                case HIDS_SUBEVENT_PROTOCOL_MODE:
                    protocol_mode = hids_subevent_protocol_mode_get_protocol_mode(packet);
                    printf("Protocol Mode: %s mode\n", hids_subevent_protocol_mode_get_protocol_mode(packet) ? "Report" : "Boot");
                    break;
                case HIDS_SUBEVENT_CAN_SEND_NOW:
                    typing_can_send_now();
                    break;
                default:
                    break;
            }
            break;
            
        default:
            break;
    }
}

void hog_keyboard_init() {
    //1. initialize ring buffer for key input
    btstack_ring_buffer_init(&key_input_buffer, key_input_storage, sizeof(key_input_storage));
    
    //2. l2cap initialize
    l2cap_init();

    //3. setup SM: Display only
    sm_init();
    sm_set_io_capabilities(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
    sm_set_authentication_requirements(SM_AUTHREQ_SECURE_CONNECTION | SM_AUTHREQ_BONDING);

    //4. setup ATT server
    att_server_init(profile_data, NULL, NULL);

    //5. setup battery service
    battery_service_server_init(battery);

    //6. setup device information service
    device_information_service_server_init();

    //7. setup HID Device service
    hids_device_init(0, hid_descriptor_keyboard_boot_mode, sizeof(hid_descriptor_keyboard_boot_mode));

    //8. setup advertisements
    uint16_t adv_int_min = 0x0030;
    uint16_t adv_int_max = 0x0030;
    uint8_t adv_type = 0;
    bd_addr_t null_addr;
    memset(null_addr, 0, 6);
    gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
    gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
    gap_advertisements_enable(1);

    //9. register for HCI events
    hci_event_callback_registration.callback = &packet_handler;
    hci_add_event_handler(&hci_event_callback_registration);

    //10. register for SM events
    sm_event_callback_registration.callback = &packet_handler;
    sm_add_event_handler(&sm_event_callback_registration);

    //11. register for HIDS
    hids_device_register_packet_handler(packet_handler);

    hci_power_control(HCI_POWER_ON);
}

int main()
{
    stdio_init_all();

    if (cyw43_arch_init()) {
        printf("cyw43_arch_init error\n");
        return 0;
    }
    //0. initialize keyboard & lvgl TFT
     pico_lvgl_tft_init(TFT_PIO, TFT_SM, TFT_SDI_GPIO, TFT_CSX_DCX_SCK_GPIO);

    pico_lvgl_display_init(5);
    pico_lvgl_xpt2046_init();
    //pico_lvgl_encoder_init(false);
  
    lvgl_keyboard_init();
 
    hog_keyboard_init();

    uint8_t c;
    while(1) {
        lv_timer_handler();
        sleep_ms(1);
        if (con_handle == HCI_CON_HANDLE_INVALID) continue;       
    }

    return 0;
}

pico_lvgl_hog_keyboard.gatt

PRIMARY_SERVICE, GAP_SERVICE
CHARACTERISTIC, GAP_DEVICE_NAME, READ, "PicoW BLE HID Keyboard"
CHARACTERISTIC, GATT_DATABASE_HASH, READ,

// add Battery Service
#import <battery_service.gatt>

// add Device ID Service
#import <device_information_service.gatt>

// add HID Service
#import <hids.gatt>

shortcuts.c

#include "stdio.h"
#include "pico/stdlib.h"
#include "pico_lvgl.h"
#define KEY_F1 0x3a // Keyboard F1
#define KEY_F2 0x3b // Keyboard F2
#define KEY_F3 0x3c // Keyboard F3
#define KEY_F4 0x3d // Keyboard F4
#define KEY_F5 0x3e // Keyboard F5
#define KEY_A 0x04 // Keyboard a and A
#define KEY_B 0x05 // Keyboard b and B
#define KEY_C 0x06 // Keyboard c and C
#define KEY_D 0x07 // Keyboard d and D
#define KEY_E 0x08 // Keyboard e and E

#define KEY_MOD_LCTRL  0x01
#define KEY_MOD_LSHIFT 0x02
#define KEY_MOD_LALT   0x04
#define KEY_MOD_LMETA  0x08
#define KEY_MOD_RCTRL  0x10
#define KEY_MOD_RSHIFT 0x20
#define KEY_MOD_RALT   0x40
#define KEY_MOD_RMETA  0x80

#define KEY_ESC 0x29 // Keyboard ESCAPE
#define KEY_BACKSPACE 0x2a // Keyboard DELETE (Backspace)
#define KEY_TAB 0x2b // Keyboard Tab
#define KEY_SPACE 0x2c // Keyboard Spacebar

void send_hid_spec_code(uint8_t modifier, uint8_t keycode);

static const char* shortcuts_map[] = {
    LV_SYMBOL_HOME "Home",  "<Back", LV_SYMBOL_OK "Select", LV_SYMBOL_PREV "Prev",LV_SYMBOL_NEXT "Next", "\n",
    "ESC", "Tab", LV_SYMBOL_CLOSE "Close", "Ctrl+SP",""
};
static const uint16_t KB_BTN = LV_KEYBOARD_CTRL_BTN_FLAGS;
static const uint16_t KB_HIDDEN = LV_BTNMATRIX_CTRL_HIDDEN;

static const uint16_t shortcuts_ctl_map[] = {
    KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,
    KB_BTN,KB_BTN,KB_BTN,KB_BTN|2
};

static void shortcuts_btnmatrix_cb(lv_event_t* e) {
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t* obj = lv_event_get_user_data(e);
    uint16_t select_btn;
    if (code == LV_EVENT_CLICKED) {
        select_btn = lv_btnmatrix_get_selected_btn(obj);
        switch(select_btn) {
            case 0:
            send_hid_spec_code(0, KEY_F1);
            break;
            case 1:
            send_hid_spec_code(0, KEY_F2);
            break;
            case 2:
            send_hid_spec_code(0, KEY_F3);
            break;
            case 3:
            send_hid_spec_code(0, KEY_F4);
            break;
            case 4:
            send_hid_spec_code(0, KEY_F5);
            break;

            case 5:
            send_hid_spec_code(0, KEY_ESC);
            break;
            case 6:
            send_hid_spec_code(0, KEY_TAB);
            break;
            case 7:
            send_hid_spec_code(KEY_MOD_LALT, KEY_F4);
            break;
            case 8:
            send_hid_spec_code(KEY_MOD_LCTRL, KEY_SPACE);
            break;
        }
    }
}
void shortcuts_init(lv_obj_t* parent) {
    lv_obj_t *shortcuts = lv_btnmatrix_create(parent);
    lv_btnmatrix_set_map(shortcuts, shortcuts_map);
    lv_btnmatrix_set_btn_ctrl_all(shortcuts, KB_BTN);
    lv_obj_set_size(shortcuts, lv_pct(100), lv_pct(100));
    lv_obj_set_style_pad_all(shortcuts, 0,0);
    lv_obj_add_event_cb(shortcuts, shortcuts_btnmatrix_cb, LV_EVENT_ALL, shortcuts);
}

usb_hid_scan_code.h

#ifndef __USB_HID_SCAN_CODE_H__
#define __USB_HID_SCAN_CODE_H__

#include "stdio.h"
#include "pico/stdlib.h"
/**
 * Modifier masks - used for the first byte in the HID report.
 * NOTE: The second byte in the report is reserved, 0x00
 */
#define KEY_MOD_LCTRL  0x01
#define KEY_MOD_LSHIFT 0x02
#define KEY_MOD_LALT   0x04
#define KEY_MOD_LMETA  0x08
#define KEY_MOD_RCTRL  0x10
#define KEY_MOD_RSHIFT 0x20
#define KEY_MOD_RALT   0x40
#define KEY_MOD_RMETA  0x80


#define KEY_NONE 0x00 // No key pressed
#define KEY_ERR_OVF 0x01 //  Keyboard Error Roll Over - used for all slots if too many keys are pressed ("Phantom key")
// 0x02 //  Keyboard POST Fail
// 0x03 //  Keyboard Error Undefined

#define SPECIAL_KEY 0xff
#define CHAR_RETURN     '\n'
#define CHAR_ESCAPE      27
#define CHAR_TAB         '\t'
#define CHAR_BACKSPACE   0x7f

#define KEY_DELETE 0x4c // Keyboard Delete Forward
#define KEY_RIGHT 0x4f // Keyboard Right Arrow
#define KEY_LEFT 0x50 // Keyboard Left Arrow
#define KEY_DOWN 0x51 // Keyboard Down Arrow
#define KEY_UP 0x52 // Keyboard Up Arrow

// special keys
#define KEY_ESC 0x29 // Keyboard ESCAPE
#define KEY_F1 0x3a // Keyboard F1
#define KEY_F2 0x3b // Keyboard F2
#define KEY_F3 0x3c // Keyboard F3
#define KEY_F4 0x3d // Keyboard F4
#define KEY_F5 0x3e // Keyboard F5
#define KEY_F6 0x3f // Keyboard F6
#define KEY_F7 0x40 // Keyboard F7
#define KEY_F8 0x41 // Keyboard F8
#define KEY_F9 0x42 // Keyboard F9
#define KEY_F10 0x43 // Keyboard F10
#define KEY_F11 0x44 // Keyboard F11
#define KEY_F12 0x45 // Keyboard F12

#define KEY_GRAVE 0x35 // Keyboard ` and ~
#define KEY_COMMA 0x36 // Keyboard , and <
#define KEY_DOT 0x37 // Keyboard . and >



static const uint8_t keytable_scan_codes[] = {
    SPECIAL_KEY,SPECIAL_KEY,SPECIAL_KEY,SPECIAL_KEY,'a','b','c','d','e','f','g','h','i','j','k','l', //0x00~0x0F
    'm','n','o','p','q','r','s','t','u','v','w','x','y','z','1','2', //0x10~0x1F
    '3','4','5','6','7','8','9','0',CHAR_RETURN, CHAR_ESCAPE, CHAR_BACKSPACE, CHAR_TAB,' ','-','=','[', //0x20~0x2F
    ']','\\',SPECIAL_KEY,';','\'','`',',','.','/',
};

static const uint8_t keytable_scan_codes_shift[] = {
    SPECIAL_KEY,SPECIAL_KEY,SPECIAL_KEY,SPECIAL_KEY,'A','B','C','D','E','F','G','H','I','J','K','L', //0x00~0x0F
    'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','!','@', //0x10~0x1F
    '#','$','%','^','&','*','(',')',CHAR_RETURN, CHAR_ESCAPE, CHAR_BACKSPACE, CHAR_TAB,' ','_','+','{', //0x20~0x2F
    '}','|',SPECIAL_KEY,':','"','~','<','>','?',
};

static const char ILLEGAL_PHONEETIC[] = "000";
static const char* keyboard_phonetic[] = {
    ILLEGAL_PHONEETIC,ILLEGAL_PHONEETIC,ILLEGAL_PHONEETIC,ILLEGAL_PHONEETIC,
    "ㄇ","ㄖ","ㄏ","ㄎ","ㄍ","ㄑ","ㄕ","ㄘ","ㄛ","ㄨ","ㄜ","ㄠ", //0x00~0x0F

    "ㄩ","ㄙ","ㄟ","ㄣ","ㄆ","ㄐ","ㄋ","ㄔ","ㄧ","ㄒ","ㄊ","ㄌ","ㄗ","ㄈ","ㄅ","ㄉ", //0x10~0x1F

    "ˇ","ˋ","ㄓ","ˊ","˙","ㄚ","ㄞ","ㄢ","換行", ILLEGAL_PHONEETIC, "←", ILLEGAL_PHONEETIC,
    " ","ㄦ","+","{", //0x20~0x2F

    "}","|",ILLEGAL_PHONEETIC,"ㄤ","\"","~","ㄝ","ㄡ","ㄥ" //0x30~0x38
};

#define REPORT_ID 0x01

// from USB HID Specification 1.1, Appendix B.1
static const uint8_t hid_descriptor_keyboard_boot_mode[] = {

    0x05, 0x01,                    // Usage Page (Generic Desktop)
    0x09, 0x06,                    // Usage (Keyboard)
    0xa1, 0x01,                    // Collection (Application)

    0x85,  0x01,                   // Report ID 1

    // Modifier byte

    0x75, 0x01,                    //   Report Size (1)
    0x95, 0x08,                    //   Report Count (8)
    0x05, 0x07,                    //   Usage Page (Key codes)
    0x19, 0xe0,                    //   Usage Minimum (Keyboard LeftControl)
    0x29, 0xe7,                    //   Usage Maxium (Keyboard Right GUI)
    0x15, 0x00,                    //   Logical Minimum (0)
    0x25, 0x01,                    //   Logical Maximum (1)
    0x81, 0x02,                    //   Input (Data, Variable, Absolute)

    // Reserved byte

    0x75, 0x01,                    //   Report Size (1)
    0x95, 0x08,                    //   Report Count (8)
    0x81, 0x03,                    //   Input (Constant, Variable, Absolute)

    // LED report + padding

    0x95, 0x05,                    //   Report Count (5)
    0x75, 0x01,                    //   Report Size (1)
    0x05, 0x08,                    //   Usage Page (LEDs)
    0x19, 0x01,                    //   Usage Minimum (Num Lock)
    0x29, 0x05,                    //   Usage Maxium (Kana)
    0x91, 0x02,                    //   Output (Data, Variable, Absolute)

    0x95, 0x01,                    //   Report Count (1)
    0x75, 0x03,                    //   Report Size (3)
    0x91, 0x03,                    //   Output (Constant, Variable, Absolute)

    // Keycodes

    0x95, 0x06,                    //   Report Count (6)
    0x75, 0x08,                    //   Report Size (8)
    0x15, 0x00,                    //   Logical Minimum (0)
    0x25, 0xff,                    //   Logical Maximum (1)
    0x05, 0x07,                    //   Usage Page (Key codes)
    0x19, 0x00,                    //   Usage Minimum (Reserved (no event indicated))
    0x29, 0xff,                    //   Usage Maxium (Reserved)
    0x81, 0x00,                    //   Input (Data, Array)

    0xc0,                          // End collection
};


#endif

zh_TW.kb.c

#include "pico/stdlib.h"
#include "stdio.h"
#include "pico_lvgl.h"
#include "jf_font.h"

extern uint8_t lvgl_kb_left[4];
extern uint8_t lvgl_kb_right[4];

const char* font_map[] = {
    "1","2","3","4","5","6","7","8","9","0","選字","\n",
    "ㄅ","ㄉ","ˇ", "ˋ","ㄓ","ˊ", "˙","ㄚ","ㄞ","ㄢ","ㄦ","\n",
    "ㄆ","ㄊ","ㄍ","ㄐ","ㄔ","ㄗ","ㄧ","ㄛ","ㄟ","ㄣ","←","\n",
    "ㄇ","ㄋ","ㄎ","ㄑ","ㄕ","ㄘ","ㄨ","ㄜ","ㄠ","ㄤ","換行","\n",
    "ㄈ","ㄌ","ㄏ","ㄒ","ㄖ","ㄙ","ㄩ","ㄝ","ㄡ","ㄥ","，","\n",
   "英","數","〈"," ","〉","﹀","︿","。",""
};

const uint16_t KB_BTN = LV_KEYBOARD_CTRL_BTN_FLAGS|1;
const uint16_t KB_HIDDEN = LV_BTNMATRIX_CTRL_HIDDEN | 1;
const uint16_t space_key_ctl = LV_BTNMATRIX_CTRL_CHECKABLE | LV_BTNMATRIX_CTRL_NO_REPEAT|2;

lv_btnmatrix_ctrl_t font_ctl_map[] = {
    KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_HIDDEN,KB_BTN,
    KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,
    KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,LV_BTNMATRIX_CTRL_CHECKED|2,
    KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,LV_BTNMATRIX_CTRL_CHECKED|2,
    KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,KB_BTN,
    LV_BTNMATRIX_CTRL_CHECKED|2,LV_BTNMATRIX_CTRL_CHECKED|2,KB_BTN,KB_BTN|6,KB_BTN,KB_BTN,KB_BTN, KB_BTN
};

void set_zh_TW_keyboard(lv_obj_t *kb) {
    lv_obj_set_style_text_font(kb, &jf_font, LV_PART_ITEMS);
    lv_keyboard_set_map(kb, LV_KEYBOARD_MODE_USER_1, font_map, font_ctl_map);
    lv_obj_set_style_text_font(kb, lv_font_default(), LV_PART_ITEMS);
    
}