RT-Thread-RT-Thread Studio使用记录（九）LittlevGL2RTT触摸屏RT-Thread问答社区

RT-Thread Studio使用记录（九）LittlevGL2RTT触摸屏

发布于 2021-01-30 10:10:10 浏览：2920 订阅该版

[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 软件包。基于正点原子的触摸屏驱动程序，修改为适配 LittlevGL2RTT 的驱动，运行 LittlevGL2RTT 的例程。

1、 打开 CubeMX 配置文件，配置 SPI1 选项。删除生成的 main.c 及 stm32f4xx_it.c ，注释掉 stm32f4xx_fal_msp.c 中的 ' #include "main.h" '，并添加 ' #include "drv_common.c" '。

![cube-config.png](https://oss-club.rt-thread.org/uploads/20210130/5dbed560c94be9e0ea9d3632d9f54f54.png)

![原理图.png](https://oss-club.rt-thread.org/uploads/20210130/eee31ae9c0a64b72c99ca9ccf7287ad5.png)

2、 在 drivers 文件夹下，新建 xpt2046.h 和 xpt2046.c 两个文件。参考正点原子的触摸屏驱动，修改程序如下：

```
#ifndef __XPT2046_H__
#define __XPT2046_H__

#include <rtthread.h>

#define TP_PRES_DOWN 0x80  //触摸屏被按下
#define TP_CATH_PRES 0x40  //有触摸屏按下了

#define RT_TOUCH_NORMAL             0
#define RT_TOUCH_CALIBRATION_DATA   1
#define RT_TOUCH_CALIBRATION        2

#define TOUCH_READ_TIMES            5

//触摸屏控制器
typedef struct
{
    void (*init)(void);           //初始化触摸屏控制器
    rt_uint8_t (*scan)(rt_uint8_t);     //扫描触摸屏。 0,屏幕坐标;1,物理坐标
    void (*adjust)(void);               //触摸屏校准
    rt_uint16_t x0;                     //原始坐标(第一次按下时的坐标)
    rt_uint16_t y0;
    rt_uint16_t x;                      //当前坐标(此次扫描时触摸屏的坐标)
    rt_uint16_t y;
    rt_uint8_t  sta;                    //笔的状态
                                //b7:按下1 / 松开0;
                                //b6:0,没有按键按下；1,有按键按下.
////////////////////////触摸屏校准参数/////////////////////////
    float xfac;
    float yfac;
    short xoff;
    short yoff;
//新增参数，当触摸屏的左右上下完全颠倒时需要用到
//touchtype=0的时候，适合左右为X坐标，上下为Y坐标的屏幕.
//touchtype=1的时候，适合左右为Y坐标，上下为X坐标的屏幕.
    rt_uint8_t touchtype;
}_m_tp_dev;

extern _m_tp_dev tp_dev;        //触摸屏控制器

#endif /* APPLICATIONS_XPT2046_H_ */

```

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

#include <rtthread.h>
#include "rtdevice.h"
#include "board.h"
#include "math.h"
#include "xpt2046.h"
#include "drv_lcd.h"
#include "stdio.h"

#include "lvgl.h"

#define DBG_TAG     "xpt2046"
#define DBG_LVL     DBG_LOG
#include    <rtdbg.h>

#define T_IRQ           GET_PIN(C, 4)
#define T_CS            GET_PIN(A, 4)
#define T_SCK           GET_PIN(A, 5)
#define T_DIN           GET_PIN(A, 6)
#define T_DOUT          GET_PIN(A, 7)
#define TOUCH_ERR_RANGE     50 //误差范围

//#define XPT2046_USING_SPI   //是否只用 spi 通信

rt_uint8_t TOUCH_X_CMD = 0x90;
rt_uint8_t TOUCH_Y_CMD = 0xD0;

#ifdef XPT2046_USING_SPI
static void MX_SPI1_Init(void);
#endif
static rt_uint8_t XPT2046_scan(rt_uint8_t tp);
static void XPT2046_adjust(void);
static rt_uint8_t XPT2046_read_xy(rt_uint16_t *x_value, rt_uint16_t *y_value);

_m_tp_dev tp_dev=
{
#ifdef XPT2046_USING_SPI
    MX_SPI1_Init,
#else
    NULL,
#endif
    XPT2046_scan,
    XPT2046_adjust,
    0,
    0,
    0,
    0,
    0,
    -0.126874,
    -0.073548,
    501,
    282,
    1,
};

#ifdef XPT2046_USING_SPI
SPI_HandleTypeDef hspi1;

/**
  * @brief SPI1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SPI1_Init(void)
{

/* USER CODE BEGIN SPI1_Init 0 */
    HAL_SPI_MspInit(&hspi1);
  /* USER CODE END SPI1_Init 0 */

/* USER CODE BEGIN SPI1_Init 1 */

/* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */

/* USER CODE END SPI1_Init 2 */
}
#endif

static void XPT2046_GPIO_Init(void)
{
    rt_pin_mode(T_CS, PIN_MODE_OUTPUT);
    rt_pin_mode(T_IRQ, PIN_MODE_INPUT_PULLUP);

#ifdef XPT2046_USING_SPI
    MX_SPI1_Init();
#else
    rt_pin_mode(T_SCK, PIN_MODE_OUTPUT);
    rt_pin_mode(T_DIN, PIN_MODE_INPUT_PULLUP);
    rt_pin_mode(T_DOUT, PIN_MODE_OUTPUT);
#endif

//    rt_pin_attach_irq(T_IRQ, PIN_IRQ_MODE_FALLING, XPT2046_get_date, RT_NULL);
//    rt_pin_irq_enable(T_IRQ, PIN_IRQ_ENABLE);
    XPT2046_read_xy(&tp_dev.x, &tp_dev.y);
}

//SPI写数据
//向触摸屏 IC 写入 1byte 数据
//num: 要写入的数据
void TP_Write_Byte(rt_uint8_t num)
{
    rt_uint8_t count=0,i=180;
    for(count=0;count<8;count++)
    {
        if(num&0x80)
            rt_pin_write(T_DOUT, 1);
        else rt_pin_write(T_DOUT, 0);
        num<<=1;
        rt_pin_write(T_SCK, 0);
        while(i--);
        rt_pin_write(T_SCK, 1);     //上升沿有效
    }
}
//SPI 读数据
//从触摸屏 IC 读取 adc 值
//CMD: 指令（X/Y）
//返回值：读到的数据
rt_uint16_t TP_Read_AD(rt_uint8_t CMD)
{
    rt_uint8_t count=0,i=250;
    rt_uint16_t Num=0;
    rt_pin_write(T_SCK, 0);//TCLK=0;     //先拉低时钟
    rt_pin_write(T_DOUT, 0);//TDIN=0;     //拉低数据线
    rt_pin_write(T_CS, 0);//TCS=0;      //选中触摸屏 IC
    TP_Write_Byte(CMD);//发送命令字
    while(i--);

rt_pin_write(T_SCK, 0);//TCLK=0;

i=250;
    while(i--);

rt_pin_write(T_SCK, 1);//TCLK=1;     //给一个时钟，清除 BUSY

i=250;
    while(i--);

rt_pin_write(T_SCK, 0);//TCLK=0;
    for(count=0;count<16;count++)//读出16位数据，只有高12位有效
    {
        Num<<=1;
        rt_pin_write(T_SCK, 0);//TCLK=0; //下降沿有效

i=250;
        while(i--);

rt_pin_write(T_SCK, 1);//TCLK=1;
        if(rt_pin_read(T_DIN))Num++;
    }
    Num>>=4;    //只有高12位有效
    rt_pin_write(T_CS, 1);//TCS=1;      //释放片选
    return(Num);
}

/**************************************************************************
* Function Name              : TOUCH_ReadData
* Description              : 采样物理坐标值
* Input              : cmd：选择要读取是 X 轴还是 Y 轴的命令，读取 X 轴的命令为：0xD0。而读取 Y 轴的命令 为：0x90
* Output              : None
* Return              : 读取到的物理坐标值
**************************************************************************/
static rt_uint16_t XPT2046_read_data(rt_uint8_t cmd)
{
    rt_uint8_t i,j;
    rt_uint8_t read_temp[2] = {0};
    rt_uint8_t write_temp[2] = {0};
    rt_uint16_t read_value[TOUCH_READ_TIMES], value;
    rt_uint32_t total_value;

/* 读取 TOUCH_READ_TIMES 次触摸值 */
    for(i=0; i<TOUCH_READ_TIMES; i++)
    {
#ifdef XPT2046_USING_SPI
        /* 打开片选 */
        rt_pin_write(T_CS, PIN_LOW);
        /* 在差分模式下，XPT2046 转换需要 24 个时钟，8 个时钟输入命令，之后 1 个时钟去除
                      忙信号，接着输出 12 位转换结果，剩下 3 个时钟是忽略位 */
        HAL_SPI_Transmit(&hspi1, (uint8_t *)&cmd, 1, 1000);

/* 读取数据 */
        HAL_SPI_TransmitReceive(&hspi1, write_temp, read_temp, 2, 100);
        read_value[i] =  (read_temp[0]<<8) + read_temp[1];

/* 将数据处理，读取到的 AD 值的只有 12 位，最低四位无用 */
        read_value[i] >>= 3;    //spi右移3位，io操作右移4位
        rt_pin_write(T_CS, PIN_HIGH);
#else
        read_value[i] = TP_Read_AD(cmd);
#endif
    }
//    rt_pin_write(T_CS, PIN_HIGH);

/* 滤波处理 */
    /* 首先从大到小排序 */
    for(i=0; i<(TOUCH_READ_TIMES - 1); i++)
    {
        for(j=i+1; j<TOUCH_READ_TIMES; j++)
        {
            /* 采样值从大到小排序排序 */

if(read_value[i] < read_value[j])
            {
                value = read_value[i];
                read_value[i] = read_value[j];
                read_value[j] = value;
            }
        }
    }

/* 去掉最大值，去掉最小值，求平均值 */
    j = TOUCH_READ_TIMES - 1;
    total_value = 0;
    for(i=1; i<j; i++)//="" 求="" y="" 的全部值
    {
        total_value += read_value[i];
    }
    value = total_value / (TOUCH_READ_TIMES - 2);

return value;
}

/**************************************************************************
* Function Name              : TOUCH_ReadXY
* Description              : 读取触摸屏的 X 轴 Y 轴的物理坐标值
* Input              : *xValue：保存读取到 X 轴物理坐标值的地址
*              * *yValue：保存读取到 Y 轴物理坐标值的地址
* Output              : None
* Return              : 1：读取成功；0：读取失败
**************************************************************************/
static rt_uint8_t XPT2046_read_xy(rt_uint16_t *x_value, rt_uint16_t *y_value)
{
    rt_uint16_t x_value1, x_value2, y_value1, y_value2;
    x_value1 = XPT2046_read_data(TOUCH_X_CMD);
    x_value2 = XPT2046_read_data(TOUCH_X_CMD);
    y_value1 = XPT2046_read_data(TOUCH_Y_CMD);
    y_value2 = XPT2046_read_data(TOUCH_Y_CMD);

/* 查看两个点之间的只采样值差距 */
    if(((x_value2<=x_value1 && x_value1<x_value2+TOUCH_ERR_RANGE) || (x_value1<=x_value2 && x_value2<x_value1+TOUCH_ERR_RANGE))//前后两次采样差值在 ±50 以内
        && ((y_value2<=y_value1 && y_value1<y_value2+TOUCH_ERR_RANGE) || (y_value1<=y_value2 && y_value2<y_value1+TOUCH_ERR_RANGE)))
    {
        *x_value = (x_value1 + x_value2) / 2;
        *y_value = (y_value1 + y_value2) / 2;
        return 1;
    }
    else
        return 0;
}

static void XPT2046_draw_touch_circle(const char *pixel, rt_uint16_t x, rt_uint16_t y, rt_uint16_t r)
{
    int a = 0, b = r;
    int di = 3 - (r<<1);//判断下个点位置的标志
    while(a <= b)
    {
        LCD_Fast_DrawPoint(pixel, x+a, y+b);    //6
        LCD_Fast_DrawPoint(pixel, x+a, y-b);    //5
        LCD_Fast_DrawPoint(pixel, x-a, y-b);    //2
        LCD_Fast_DrawPoint(pixel, x-a, y+b);    //1
        LCD_Fast_DrawPoint(pixel, x+b, y+a);    //4
        LCD_Fast_DrawPoint(pixel, x+b, y-a);    //0
        LCD_Fast_DrawPoint(pixel, x-b, y-a);    //7
        LCD_Fast_DrawPoint(pixel, x-b, y+a);    //3

a++;
        //使用 Bresenham 算法画圆
        if(di < 0)
            di += 4*a + 6;
        else
        {
            di += 10 + 4*(a-b);
            b--;
        }
    }
}

static void XPT2046_draw_touch_point(const char *pixel, rt_uint16_t x, rt_uint16_t y)
{
    LCD_HLine(pixel, x-12, x+13, y);
    LCD_VLine(pixel, x, y-12, y+13);
    LCD_Fast_DrawPoint(pixel, x+1, y+1);
    LCD_Fast_DrawPoint(pixel, x-1, y+1);
    LCD_Fast_DrawPoint(pixel, x+1, y-1);
    LCD_Fast_DrawPoint(pixel, x-1, y-1);
    XPT2046_draw_touch_circle(pixel, x, y, 6);
}

static rt_uint8_t touch_state = 0;

//触摸按键扫描
//tp:0,屏幕坐标；1,物理坐标(校准等特殊场合用)
//返回值：当前触摸屏状态
//0,无触摸；1,有触摸
static rt_uint8_t XPT2046_scan(rt_uint8_t tp)
{
    if(rt_pin_read(T_IRQ) == 0) //有按键按下
    {
        if(tp)//读取物理坐标
        {
            XPT2046_read_xy(&tp_dev.x, &tp_dev.y);
        }
        else if(XPT2046_read_xy(&tp_dev.x, &tp_dev.y))  //读取屏幕坐标
        {
            tp_dev.x=tp_dev.xfac*tp_dev.x+tp_dev.xoff;//将结果转换为屏幕坐标
            tp_dev.y=tp_dev.yfac*tp_dev.y+tp_dev.yoff;
        }
        if((tp_dev.sta & TP_PRES_DOWN) == 0) //之前没有被按下
        {
            tp_dev.sta = TP_PRES_DOWN | TP_CATH_PRES;   //按键按下
            tp_dev.x0 = tp_dev.x;   //记录第一次按下时的坐标
            tp_dev.y0 = tp_dev.y;
        }
        touch_state = 1;
//        rt_kprintf("x: %d, y: %d, touch: %d", tp_dev.x, tp_dev.y, touch_state);
    }
    else    //没有按键按下
    {
        if(tp_dev.sta & TP_PRES_DOWN)   //之前是被按下的
        {
            tp_dev.sta &= ~(1<<7);  //标记按键松开
        }
        else    //之前就没有被按下
        {
            tp_dev.x0 = 0;
            tp_dev.y0 = 0;
            tp_dev.x = 0xffff;
            tp_dev.y = 0xffff;
        }
//        rt_kprintf("x3: %d, y3: %d, touch: %d \r\n", tp_dev.x, tp_dev.y, touch_state);
    }
    return (tp_dev.sta & TP_PRES_DOWN); //返回当前的触摸屏状态
}

static void XPT2046_save_adjdata(void)
{
    char buf[30];
//  s32 temp;
//  保存校准结果
//  temp=tp_dev.xfac*100000000;//保存 X 校正因素
    sprintf(buf, "tp_dev.xfac = %f", tp_dev.xfac);
    rt_kprintf("%s",buf);
//  temp=tp_dev.yfac*100000000;//保存 Y 校正因素
    sprintf(buf, "tp_dev.xfac = %f", tp_dev.yfac);
    rt_kprintf("%s",buf);
//  保存 X 偏移量
    rt_kprintf("tp_dev.xoff = %d",tp_dev.xoff);
//  保存 Y 偏移量
    rt_kprintf("tp_dev.yoff = %d",tp_dev.yoff);
//  保存触屏类型
    rt_kprintf("tp_dev.touchtype = %d\r\n",tp_dev.touchtype);
//  temp=0X0A;//标记校准过了
}

static void XPT2046_adjust(void)
{
    rt_uint16_t pos_temp[4][2];//坐标缓存值
    rt_uint8_t  cnt = 0;
    rt_uint16_t d1,d2;
    rt_uint32_t tem1,tem2;
    float fac;
    rt_uint16_t outtime = 0;
    cnt=0;
    rt_uint16_t pixel = 0xf100;
    rt_uint16_t back_color = 0xffff;
    LCD_Clear(back_color);//清屏

XPT2046_draw_touch_point((const char*)&pixel, 20, 20);//画点1
    tp_dev.sta=0;//清除触发信号
    tp_dev.xfac=0;//xfac用来标记是否校准过,所以校准之前必须清掉，以免错误
    while(1)//如果连续 10s 没有按下，则自动退出
    {
        tp_dev.scan(1);//扫描物理坐标
        if((tp_dev.sta & 0xc0) == TP_CATH_PRES)//按键按下了一次(此时按键松开了)
        {
            outtime = 0;
            tp_dev.sta &= ~(1<<6);//标记按键已经被处理过了

pos_temp[cnt][0] = tp_dev.x;
            pos_temp[cnt][1] = tp_dev.y;
            cnt++;
            switch(cnt)
            {
                case 1:
                    XPT2046_draw_touch_point((const char*)&back_color, 20, 20);               //清除点1
                    XPT2046_draw_touch_point((const char*)&pixel, lcddev.width-20,20);    //画点2
                    break;
                case 2:
                    XPT2046_draw_touch_point((const char*)&back_color, lcddev.width-20,20);  //清除点2
                    XPT2046_draw_touch_point((const char*)&pixel, 20,lcddev.height-20);   //画点3
                    break;
                case 3:
                    XPT2046_draw_touch_point((const char*)&back_color, 20,lcddev.height-20);         //清除点3
                    XPT2046_draw_touch_point((const char*)&pixel, lcddev.width-20,lcddev.height-20);  //画点4
                    break;
                case 4:  //全部四个点已经得到
                    //对边相等
                    tem1 = abs(pos_temp[0][0] - pos_temp[1][0]);//x1-x2
                    tem2 = abs(pos_temp[0][1] - pos_temp[1][1]);//y1-y2
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d1 = sqrt(tem1 + tem2);//得到1，2两点的距离

tem1 = abs(pos_temp[2][0] - pos_temp[3][0]);//x3-x4
                    tem2 = abs(pos_temp[2][1] - pos_temp[3][1]);//y3-y4
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d2 = sqrt(tem1 + tem2);//得到3、4两点的距离
                    fac = (float)d1 / d2;
                    if(fac<0.95 || fac>1.05 || d1==0 || d2==0)//不合格
                    {
                        cnt = 0;
                        XPT2046_draw_touch_point((const char*)&back_color, lcddev.width-20,lcddev.height-20);    //清除点4
                        XPT2046_draw_touch_point((const char*)&pixel, 20,20);                             //画点1
//                        TP_Adj_Info_Show(pos_temp[0][0],pos_temp[0][1],pos_temp[1][0],pos_temp[1][1],pos_temp[2][0],pos_temp[2][1],pos_temp[3][0],pos_temp[3][1],fac*100);//显示数据
                        continue;
                    }

tem1 = abs(pos_temp[0][0] - pos_temp[2][0]);//x1-x3
                    tem2 = abs(pos_temp[0][1] - pos_temp[2][1]);//y1-y3
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d1 = sqrt(tem1 + tem2);//得到2、3的距离

tem1 = abs(pos_temp[1][0] - pos_temp[3][0]);//x2-x4
                    tem2 = abs(pos_temp[1][1] - pos_temp[3][1]);//y2-y4
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d2 = sqrt(tem1 + tem2);//得到1、4的距离
                    fac = (float)d1 / d2;
                    if(fac<0.95 || fac>1.05)//不合格
                    {
                        cnt = 0;
                        XPT2046_draw_touch_point((const char*)&back_color, lcddev.width-20,lcddev.height-20);    //清除点4
                        XPT2046_draw_touch_point((const char*)&pixel, 20,20);                             //画点1
//                        TP_Adj_Info_Show(pos_temp[0][0],pos_temp[0][1],pos_temp[1][0],pos_temp[1][1],pos_temp[2][0],pos_temp[2][1],pos_temp[3][0],pos_temp[3][1],fac*100);//显示数据
                        continue;
                    }

//正确了
                    //对角线相等
                    tem1 = abs(pos_temp[1][0] - pos_temp[2][0]);//x1-x3
                    tem2 = abs(pos_temp[1][1] - pos_temp[2][1]);//y1-y3
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d1 = sqrt(tem1 + tem2);//得到2、3的距离

tem1 = abs(pos_temp[0][0] - pos_temp[3][0]);//x2-x4
                    tem2 = abs(pos_temp[0][1] - pos_temp[3][1]);//y2-y4
                    tem1 *= tem1;
                    tem2 *= tem2;
                    d2 = sqrt(tem1 + tem2);//得到1、4的距离
                    fac = (float)d1 / d2;
                    if(fac<0.95 || fac>1.05)//不合格
                    {
                        cnt = 0;
                        XPT2046_draw_touch_point((const char*)&back_color, lcddev.width-20,lcddev.height-20);    //清除点4
                        XPT2046_draw_touch_point((const char*)&pixel, 20,20);                             //画点1
//                        TP_Adj_Info_Show(pos_temp[0][0],pos_temp[0][1],pos_temp[1][0],pos_temp[1][1],pos_temp[2][0],pos_temp[2][1],pos_temp[3][0],pos_temp[3][1],fac*100);//显示数据
                        continue;
                    }//正确了
                    //计算结果
//                    TP_Adj_Info_Show(pos_temp[0][0],pos_temp[0][1],pos_temp[1][0],pos_temp[1][1],pos_temp[2][0],pos_temp[2][1],pos_temp[3][0],pos_temp[3][1],fac*100);//ÏÔÊ¾Êý¾Ý
                    tp_dev.xfac = (float)(lcddev.width - 40) / (pos_temp[1][0] - pos_temp[0][0]);//得到xfac
                    tp_dev.xoff = (lcddev.width - tp_dev.xfac * (pos_temp[1][0] + pos_temp[0][0])) / 2;//得到xoff

tp_dev.yfac = (float)(lcddev.height - 40) / (pos_temp[2][1] - pos_temp[0][1]);//得到yfac
                    tp_dev.yoff = (lcddev.height - tp_dev.yfac * (pos_temp[2][1] + pos_temp[0][1])) / 2;//得到yoff
                    if(abs(tp_dev.xfac)>2 || abs(tp_dev.yfac)>2)//触摸屏和预设的相反了
                    {
                        cnt = 0;
                        XPT2046_draw_touch_point((const char*)&back_color, lcddev.width-20,lcddev.height-20);    //清除点4
                        XPT2046_draw_touch_point((const char*)&pixel, 20,20);                             //画点1

tp_dev.touchtype = !tp_dev.touchtype;//修改触屏类型
                        if(tp_dev.touchtype)//X,Y方向与屏幕相反
                        {
                            TOUCH_X_CMD = 0X90;
                            TOUCH_Y_CMD = 0XD0;
                        }else               //X,Y方向与屏幕相同
                        {
                            TOUCH_X_CMD = 0XD0;
                            TOUCH_Y_CMD = 0X90;
                        }
                        continue;
                    }

LCD_Clear(back_color);//清屏
                  rt_thread_delay(1000);
                  XPT2046_save_adjdata();
                  LCD_Clear(back_color);//清屏
                  return;//矫正完成
            }
        }
        rt_thread_delay(10);
        outtime++;
        if(outtime>1000)
        {
//            TP_Get_Adjdata();
            break;
        }
    }
}

static bool touch_read(lv_indev_drv_t *drv, lv_indev_data_t *data)
{
    static rt_uint16_t last_x = 0;
    static rt_uint16_t last_y = 0;

if(tp_dev.sta & TP_PRES_DOWN)//触摸按下了     //(touch_state == 1)
    {
        data->point.x = tp_dev.x;
        data->point.y = tp_dev.y;
        data->state = LV_INDEV_STATE_PR;
        last_x = data->point.x;
        last_y = data->point.y;
        touch_state = 0;
//        rt_kprintf("x0: %d, y0: %d ;, touch: %d  ", tp_dev.x, tp_dev.y, touch_state);
    }
    else
    {
        data->point.x = last_x;
        data->point.y = last_y;
        data->state = LV_INDEV_STATE_REL;
//        rt_kprintf("x1: %d, y1: %d , touch: %d \r\n", last_x, last_y);
    }

return RT_EOK;
}

static void xpt2046_thread_entry(void *parameter)
{
    lv_indev_drv_t indev_drv;

XPT2046_GPIO_Init();
//    XPT2046_adjust();

rt_thread_mdelay(500);      //等待其他模块初始化完成

lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = touch_read;
    lv_indev_drv_register(&indev_drv);

for(;;)
    {
        if(XPT2046_scan(0))
        {
//            touch_state = 1;
//            XPT2046_save_adjdata();
        }
        rt_thread_mdelay(30);
    }
}

#define XPT2046_THREAD_PRIORITY     20
#define XPT2046_THREAD_STACK_SIZE   1024
#define XPT2046_THREAD_TIMELICE     5
ALIGN(RT_ALIGN_SIZE)
static rt_uint8_t xpt2046_thread_stack[ XPT2046_THREAD_STACK_SIZE ];

int xpt2046_init(void)
{
    static struct rt_thread xpt2046_thread;
    rt_err_t result;

result = rt_thread_init(&xpt2046_thread,
                            "xpt2046",
                            xpt2046_thread_entry,
                            RT_NULL,
                            (rt_uint8_t*)&xpt2046_thread_stack[0],
                            XPT2046_THREAD_STACK_SIZE,
                            XPT2046_THREAD_PRIORITY,
                            XPT2046_THREAD_TIMELICE);

if(RT_EOK == result)
    {
        rt_thread_startup(&xpt2046_thread);
    }

return RT_EOK;
}
//INIT_APP_EXPORT(xpt2046_init);

```

3、在 main 函数中调用 xpt2046_init()

![main.png](https://oss-club.rt-thread.org/uploads/20210131/30f2c43f8ba48f2ddebde57564d4ad0f.png)

4、编译，下载。

![效果.gif](https://oss-club.rt-thread.org/uploads/20210130/b8d288e37c5602f8efe62476870887f8.gif)