GT911触摸芯片

芯片介绍

GT911 是专为 7”~8”设计的新一代 5 点电容触控方案，拥有 26 个驱动通道和 14 个感 应通道，以满足更高的 touch 精度要求。 GT911 可同时识别 5 个触摸点位的实时准确位置，移动轨迹及触摸面积。并可根据主控需要，读取相应点数的触摸信息。

芯片原理图

管脚定义

I2C通信

GT911 提供标准的 I 2 C 通讯接口，由 SCL 和 SDA 与主 CPU 进行通讯。 在系统中 GT911 始终作为从设备，所有通讯都是由主 CPU 发起，建议通讯速度为 400Kbps 或 以下。其支持的 I 2 C 硬件电路支持时序如下：

GT911 的 I 2 C 从设备地址有两组，分别为 0xBA/0xBB 和 0x28/0x29。主控在上电初始 化时控制 Reset 和 INT 口状态进行设定，设定方法及时序图如下：

上电时序图：

设定地址为0x28/0x29的时序：

设定地址为 0xBA/0xBB 的时序：

IIC通信实例（以设备地址为 0xBA/0xBB 为例）

数据传输

通讯总是由主 CPU 发起，有效的起始信号为：在 SCL 保持为“1”时，SDA 上发生由“1” 到“0”的跳变。地址信息或数据流均在起始信号之后传输。

所有连接在I 2 C总线上的从设备，都要检测总线上起始信号之后所发送的8位地址信息， 并做出正确反应。在收到与自己相匹配的地址信息时，GT911 在第 9 个时钟周期，将 SDA 改为输出口，并置“0”作为应答信号。若收到不与自己匹配的地址信息，即非 0XBA 或 0XBB，GT911 将保持闲置状态。

SDA 口上的数据按 9 个时钟周期串行发送 9 位数据：8 位有效数据+1 位接收方发送的 应答信号 ACK 或非应答信号 NACK。数据传输在 SCL 为“1”时有效。 当通讯完成时，由主 CPU 发送停止信号。停止信号是当 SCL 为“1”时，SDA 状态由“0” 到“1”的跳变。

对 GT911 写操作

上图为主 CPU 对 GT911 进行的写操作流程图。

首先主 CPU 产生一个起始信号，然后 发送地址信息及读写位信息“0”表示写操作:0XBA。 在收到应答后，主 CPU 发送寄存器的 16 位地址，随后是 8 位要写入到寄存器的数据 内容。 GT911 寄存器的地址指针会在写操作后自动加 1，所以当主 CPU 需要对连续地址的寄 存器进行写操作时，可以在一次写操作中连续写入。写操作完成，主 CPU 发送停止信 号结束当前写操作。

对 GT911 读操作

上图为主 CPU 对 GT911 进行的读操作流程图。

首先主 CPU 产生一个起始信号，然后 发送设备地址信息及读写位信息“0”表示写操作：0XBA。 在收到应答后，主 CPU 发送首寄存器的 16 位地址信息，设置要读取的寄存器地址。 在收到应答后，主 CPU 重新发送一次起始信号，发送读操作：0XBB。收到应答后， 主 CPU 开始读取数据

GT911 同样支持连续的读操作，默认为连续读取数据。主 CPU 在每收到一个 Byte 数 据后需发送一个应答信号表示成功接收。在接收到所需的最后一个Byte数据后，主CPU 发送“非应答信号 NACK”，然后再发送停止信号结束通讯。

详细代码

主函数

/**
  ******************************************************************************
  * @file    main.c
  * @author  GYLJ
  * @version V1.0
  * @date    2022-10-xx
  * @brief   电容触摸屏-GT911触摸芯片测试
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火  STM32 F103 霸道开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */
  
#include "stm32f10x.h"   // 相当于51单片机中的  #include <reg51.h>
#include "gt9xx.h"
#include "bsp_usart.h"
#include "core_delay.h" 
/**
  * @brief  主函数
  * @param  无  
  * @retval 无
  */
int main ( void )
{
    USART_Config();    
    /* 初始化内核定时器 */
    CPU_TS_TmrInit();
    /* 触摸芯片初始化 */
    GTP_Init_Panel(); 
    printf("\r\n ********** 触摸面板程序 *********** \r\n");
    while ( 1 )
    {
    }
}

GT9xx.C

/**
  ******************************************************************************
  * @file    gtxx.c
  * @author  fire
  * @version V1.0
  * @date    2015-xx-xx
  * @brief   i2c电容屏驱动函数gt9157/GT917S/gt5688芯片
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火  STM32 F429 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "gt9xx.h"
#include "bsp_i2c_touch.h"

// 7寸屏GT917S驱动配置
const uint8_t CTP_CFG_GT917S[] =  {
  0x84,0x20,0x03,0xE0,0x01,0x05,0x05,0x00,0x00,0x40,
  0x00,0x0F,0x78,0x64,0x53,0x11,0x00,0x00,0x00,0x00,
  0x23,0x17,0x19,0x1D,0x0F,0x04,0x00,0x00,0x00,0x00,
  0x00,0x00,0x04,0x51,0x14,0x00,0x00,0x00,0x00,0x00,
  0x32,0x00,0x00,0x50,0x38,0x28,0x8A,0x20,0x11,0x37,
  0x39,0xA2,0x07,0x38,0x6D,0x28,0x11,0x03,0x24,0x00,
  0x01,0x28,0x50,0xC0,0x94,0x02,0x00,0x00,0x53,0xB8,
  0x2E,0xA2,0x35,0x8F,0x3B,0x80,0x42,0x75,0x49,0x6B,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x4C,0x3C,
  0xFF,0xFF,0x07,0x14,0x14,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x50,0x73,
  0x50,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x1F,0x1D,0x1B,0x1A,0x19,0x18,0x17,0x16,0x15,0x09,
  0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0xFF,0xFF,0xFF,
  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  0xFF,0xFF,0x1C,0x1B,0x1A,0x19,0x18,0x17,0x15,0x14,
  0x13,0x12,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x05,0x00,0x00,0x0F,
  0x00,0x00,0x00,0x80,0x46,0x08,0x96,0x50,0x32,0x0A,
  0x0A,0x64,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  0x32,0x03,0x0C,0x08,0x23,0x00,0x14,0x23,0x00,0x28,
  0x46,0x30,0x3C,0xD0,0x07,0x50,0x70,0xB0,0x01
};

//uint8_t config[GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH]
//                = {GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff};

/* 触摸IC类型默认为5寸屏的ic */
TOUCH_IC touchIC = GT917S;        

const TOUCH_PARAM_TypeDef touch_param[1] = 
{
  /* GT917S,4.3寸屏 */
  {
    .max_width = 800,
    .max_height = 480,
    .config_reg_addr = 0x8050,
  }
};

static int8_t GTP_I2C_Test(void);
//static void GT91xx_Config_Read_Proc(void);

static void Delay(__IO uint32_t nCount)     //简单的延时函数
{
    for(; nCount != 0; nCount--);
}


/**
  * @brief   使用IIC进行数据传输
  * @param
  *        @arg i2c_msg:数据传输结构体
  *        @arg num:数据传输结构体的个数
  * @retval  正常完成的传输结构个数，若不正常，返回0xff
  */
static int I2C_Transfer( struct i2c_msg *msgs,int num)
{
    int im = 0;
    int ret = 0;

    GTP_DEBUG_FUNC();

    for (im = 0; ret == 0 && im != num; im++)
    {
        if ((msgs[im].flags&I2C_M_RD))                                                                //根据flag判断是读数据还是写数据
        {
            ret = I2C_ReadBytes(msgs[im].addr, msgs[im].buf, msgs[im].len);        //IIC读取数据
        } else
        {
            ret = I2C_WriteBytes(msgs[im].addr,  msgs[im].buf, msgs[im].len);    //IIC写入数据
        }
    }

    if(ret)
        return ret;

    return im;                                                       //正常完成的传输结构个数
}

/**
  * @brief   从IIC设备中读取数据
  * @param
  *        @arg client_addr:设备地址
  *        @arg  buf[0~1]: 读取数据寄存器的起始地址
  *        @arg buf[2~len-1]: 存储读出来数据的缓冲buffer
  *        @arg len:    GTP_ADDR_LENGTH + read bytes count（寄存器地址长度+读取的数据字节数）
  * @retval  i2c_msgs传输结构体的个数，2为成功，其它为失败
  */
static int32_t GTP_I2C_Read(uint8_t client_addr, uint8_t *buf, int32_t len)
{
    struct i2c_msg msgs[2];
    int32_t ret=-1;
    int32_t retries = 0;

    GTP_DEBUG_FUNC();
    /*一个读数据的过程可以分为两个传输过程:
     * 1. IIC  写入 要读取的寄存器地址
     * 2. IIC  读取  数据
     * */

    msgs[0].flags = !I2C_M_RD;                    //写入
    msgs[0].addr  = client_addr;                    //IIC设备地址
    msgs[0].len   = GTP_ADDR_LENGTH;    //寄存器地址为2字节(即写入两字节的数据)
    msgs[0].buf   = &buf[0];                        //buf[0~1]存储的是要读取的寄存器地址
    
    msgs[1].flags = I2C_M_RD;                    //读取
    msgs[1].addr  = client_addr;                    //IIC设备地址
    msgs[1].len   = len - GTP_ADDR_LENGTH;    //要读取的数据长度
    msgs[1].buf   = &buf[GTP_ADDR_LENGTH];    //buf[GTP_ADDR_LENGTH]之后的缓冲区存储读出的数据

    while(retries < 5)
    {
        ret = I2C_Transfer( msgs, 2);                    //调用IIC数据传输过程函数，有2个传输过程
        if(ret == 2)break;
        retries++;
    }
    if((retries >= 5))
    {
        GTP_ERROR("I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((uint16_t)(buf[0] << 8)) | buf[1]), len-2, ret);
    }
    return ret;
}



/**
  * @brief   向IIC设备写入数据
  * @param
  *        @arg client_addr:设备地址
  *        @arg  buf[0~1]: 要写入的数据寄存器的起始地址
  *        @arg buf[2~len-1]: 要写入的数据
  *        @arg len:    GTP_ADDR_LENGTH + write bytes count（寄存器地址长度+写入的数据字节数）
  * @retval  i2c_msgs传输结构体的个数，1为成功，其它为失败
  */
static int32_t GTP_I2C_Write(uint8_t client_addr,uint8_t *buf,int32_t len)
{
    struct i2c_msg msg;
    int32_t ret = -1;
    int32_t retries = 0;

    GTP_DEBUG_FUNC();
    /*一个写数据的过程只需要一个传输过程:
     * 1. IIC连续 写入 数据寄存器地址及数据
     * */
    msg.flags = !I2C_M_RD;            //写入
    msg.addr  = client_addr;            //从设备地址
    msg.len   = len;                            //长度直接等于(寄存器地址长度+写入的数据字节数)
    msg.buf   = buf;                        //直接连续写入缓冲区中的数据(包括了寄存器地址)

    while(retries < 5)
    {
        ret = I2C_Transfer(&msg, 1);    //调用IIC数据传输过程函数，1个传输过程
        if (ret == 1)break;
        retries++;
    }
    if((retries >= 5))
    {

        GTP_ERROR("I2C Write: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((uint16_t)(buf[0] << 8)) | buf[1]), len-2, ret);

    }
    return ret;
}



/**
  * @brief   使用IIC读取再次数据，检验是否正常
  * @param
  *        @arg client:设备地址
  *        @arg  addr: 寄存器地址
  *        @arg rxbuf: 存储读出的数据
  *        @arg len:    读取的字节数
  * @retval
  *     @arg FAIL
  *     @arg SUCCESS
  */
 int32_t GTP_I2C_Read_dbl_check(uint8_t client_addr, uint16_t addr, uint8_t *rxbuf, int len)
{
    uint8_t buf[16] = {0};
    uint8_t confirm_buf[16] = {0};
    uint8_t retry = 0;
    
    GTP_DEBUG_FUNC();

    while (retry++ < 3)
    {
        memset(buf, 0xAA, 16);
        buf[0] = (uint8_t)(addr >> 8);
        buf[1] = (uint8_t)(addr & 0xFF);
        GTP_I2C_Read(client_addr, buf, len + 2);
        
        memset(confirm_buf, 0xAB, 16);
        confirm_buf[0] = (uint8_t)(addr >> 8);
        confirm_buf[1] = (uint8_t)(addr & 0xFF);
        GTP_I2C_Read(client_addr, confirm_buf, len + 2);

      
        if (!memcmp(buf, confirm_buf, len+2))
        {
            memcpy(rxbuf, confirm_buf+2, len);
            return SUCCESS;
        }
    }    
    GTP_ERROR("I2C read 0x%04X, %d bytes, double check failed!", addr, len);
    return FAIL;
}


/**
  * @brief   关闭GT91xx中断
  * @param 无
  * @retval 无
  */
void GTP_IRQ_Disable(void)
{

    GTP_DEBUG_FUNC();

}

/**
  * @brief   使能GT91xx中断
  * @param 无
  * @retval 无
  */
void GTP_IRQ_Enable(void)
{
    GTP_DEBUG_FUNC();
    I2C_GTP_IRQEnable();
}


/**
  * @brief   用于处理或报告触屏检测到按下
  * @param
  *    @arg     id: 触摸顺序trackID
  *    @arg     x:  触摸的 x 坐标
  *    @arg     y:  触摸的 y 坐标
  *    @arg     w:  触摸的 大小
  * @retval 无
  */
/*用于记录连续触摸时(长按)的上一次触摸位置，负数值表示上一次无触摸按下*/
volatile static int16_t pre_x[GTP_MAX_TOUCH] ={-1,-1,-1,-1,-1};
volatile static int16_t pre_y[GTP_MAX_TOUCH] ={-1,-1,-1,-1,-1};

static void GTP_Touch_Down(int32_t id,int32_t x,int32_t y,int32_t w)
{
  
    GTP_DEBUG_FUNC();

    /*取x、y初始值大于屏幕像素值*/
    GTP_DEBUG("ID:%d, X:%d, Y:%d, W:%d", id, x, y, w);

    /************************************/
    /*在此处添加自己的触摸点按下时处理过程即可*/
    /* (x,y) 即为最新的触摸点 *************/
    /************************************/
    
    /*prex,prey数组存储上一次触摸的位置，id为轨迹编号(多点触控时有多轨迹)*/
    pre_x[id] = x; pre_y[id] =y;
    
}


/**
  * @brief   用于处理或报告触屏释放
  * @param 释放点的id号
  * @retval 无
  */
static void GTP_Touch_Up( int32_t id)
{
    /*****************************************/
    /*在此处添加自己的触摸点释放时的处理过程即可*/
    /* pre_x[id],pre_y[id] 即为最新的释放点 ****/
    /*******************************************/    
    /***id为轨迹编号(多点触控时有多轨迹)********/
    

    /*触笔释放，把pre xy 重置为负*/
      pre_x[id] = -1;
      pre_y[id] = -1;        
  
    GTP_DEBUG("Touch id[%2d] release!", id);

}

/**
  * @brief   触屏处理函数，轮询或者在触摸中断调用
  * @param 无
  * @retval 无
  */
static void Goodix_TS_Work_Func(void)
{
    uint8_t  end_cmd[3] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0};
    uint8_t  point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1]={GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF};
    uint8_t  touch_num = 0;
    uint8_t  finger = 0;
    static uint16_t pre_touch = 0;
    static uint8_t pre_id[GTP_MAX_TOUCH] = {0};

    uint8_t client_addr=GTP_ADDRESS;
    uint8_t* coor_data = NULL;
    int32_t input_x = 0;
    int32_t input_y = 0;
    int32_t input_w = 0;
    uint8_t id = 0;
 
    int32_t i  = 0;
    int32_t ret = -1;

    GTP_DEBUG_FUNC();

    ret = GTP_I2C_Read(client_addr, point_data, 12);//10字节寄存器加2字节地址
    if (ret < 0)
    {
        GTP_ERROR("I2C transfer error. errno:%d\n ", ret);

        return;
    }
    
    finger = point_data[GTP_ADDR_LENGTH];//状态寄存器数据

    if (finger == 0x00)        //没有数据，退出
    {
        return;
    }

    if((finger & 0x80) == 0)//判断buffer status位
    {
        goto exit_work_func;//坐标未就绪，数据无效
    }

    touch_num = finger & 0x0f;//坐标点数
    if (touch_num > GTP_MAX_TOUCH)
    {
        goto exit_work_func;//大于最大支持点数，错误退出
    }

    if (touch_num > 1)//不止一个点
    {
        uint8_t buf[8 * GTP_MAX_TOUCH] = {(GTP_READ_COOR_ADDR + 10) >> 8, (GTP_READ_COOR_ADDR + 10) & 0xff};

        ret = GTP_I2C_Read(client_addr, buf, 2 + 8 * (touch_num - 1));
        memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1));            //复制其余点数的数据到point_data
    }

    
    
    if (pre_touch>touch_num)                //pre_touch>touch_num,表示有的点释放了
    {
        for (i = 0; i < pre_touch; i++)                        //一个点一个点处理
         {
            uint8_t j;
           for(j=0; j<touch_num; j++)
           {
               coor_data = &point_data[j * 8 + 3];
               id = coor_data[0] & 0x0F;                                    //track id
              if(pre_id[i] == id)
                break;

              if(j >= touch_num-1)                                            //遍历当前所有id都找不到pre_id[i]，表示已释放
              {
                 GTP_Touch_Up( pre_id[i]);
              }
           }
       }
    }


    if (touch_num)
    {
        for (i = 0; i < touch_num; i++)                        //一个点一个点处理
        {
            coor_data = &point_data[i * 8 + 3];

            id = coor_data[0] & 0x0F;                                    //track id
            pre_id[i] = id;

            input_x  = coor_data[1] | (coor_data[2] << 8);    //x坐标
            input_y  = coor_data[3] | (coor_data[4] << 8);    //y坐标
            input_w  = coor_data[5] | (coor_data[6] << 8);    //size
        
            {
                GTP_Touch_Down( id, input_x, input_y, input_w);//数据处理其中 480-input_y 是为了换一下y的方向
            }
        }
    }
    else if (pre_touch)        //touch_ num=0 且pre_touch！=0
    {
      for(i=0;i<pre_touch;i++)
      {
          GTP_Touch_Up(pre_id[i]);
      }
    }


    pre_touch = touch_num;


exit_work_func:
    {
        ret = GTP_I2C_Write(client_addr, end_cmd, 3);
        if (ret < 0)
        {
            GTP_INFO("I2C write end_cmd error!");
        }
    }

}


/**
  * @brief   给触屏芯片重新复位
  * @param 无
  * @retval 无
  */
 int8_t GTP_Reset_Guitar(void)
{
    GTP_DEBUG_FUNC();
#if 1
    I2C_ResetChip();
    return 0;
#else         //软件复位
    int8_t ret = -1;
    int8_t retry = 0;
    uint8_t reset_command[3]={(uint8_t)GTP_REG_COMMAND>>8,(uint8_t)GTP_REG_COMMAND&0xFF,2};

    //写入复位命令
    while(retry++ < 5)
    {
        ret = GTP_I2C_Write(GTP_ADDRESS, reset_command, 3);
        if (ret > 0)
        {
            GTP_INFO("GTP enter sleep!");

            return ret;
        }

    }
    GTP_ERROR("GTP send sleep cmd failed.");
    return ret;
#endif

}



 /**
   * @brief   进入睡眠模式
   * @param 无
   * @retval 1为成功，其它为失败
   */
//int8_t GTP_Enter_Sleep(void)
//{
//    int8_t ret = -1;
//    int8_t retry = 0;
//    uint8_t reset_comment[3] = {(uint8_t)(GTP_REG_COMMENT >> 8), (uint8_t)GTP_REG_COMMENT&0xFF, 5};//5
//
//    GTP_DEBUG_FUNC();
//
//    while(retry++ < 5)
//    {
//        ret = GTP_I2C_Write(GTP_ADDRESS, reset_comment, 3);
//        if (ret > 0)
//        {
//            GTP_INFO("GTP enter sleep!");
//
//            return ret;
//        }
//
//    }
//    GTP_ERROR("GTP send sleep cmd failed.");
//    return ret;
//}


int8_t GTP_Send_Command(uint8_t command)
{
    int8_t ret = -1;
    int8_t retry = 0;
    uint8_t command_buf[3] = {(uint8_t)(GTP_REG_COMMAND >> 8), (uint8_t)GTP_REG_COMMAND&0xFF, GTP_COMMAND_READSTATUS};

    GTP_DEBUG_FUNC();

    while(retry++ < 5)
    {
        ret = GTP_I2C_Write(GTP_ADDRESS, command_buf, 3);
        if (ret > 0)
        {
            GTP_INFO("send command success!");

            return ret;
        }

    }
    GTP_ERROR("send command fail!");
    return ret;
}

/**
  * @brief   唤醒触摸屏
  * @param 无
  * @retval 0为成功，其它为失败
  */
int8_t GTP_WakeUp_Sleep(void)
{
    uint8_t retry = 0;
    int8_t ret = -1;

    GTP_DEBUG_FUNC();

    while(retry++ < 10)
    {
        ret = GTP_I2C_Test();
        if (ret > 0)
        {
            GTP_INFO("GTP wakeup sleep.");
            return ret;
        }
        GTP_Reset_Guitar();
    }

    GTP_ERROR("GTP wakeup sleep failed.");
    return ret;
}

static int32_t GTP_Get_Info(void)
{
    uint8_t opr_buf[10] = {0};
    int32_t ret = 0;

    uint16_t abs_x_max = GTP_MAX_WIDTH;
    uint16_t abs_y_max = GTP_MAX_HEIGHT;
    uint8_t int_trigger_type = GTP_INT_TRIGGER;
        
    opr_buf[0] = (uint8_t)((GTP_REG_CONFIG_DATA+1) >> 8);
    opr_buf[1] = (uint8_t)((GTP_REG_CONFIG_DATA+1) & 0xFF);
    
    ret = GTP_I2C_Read(GTP_ADDRESS, opr_buf, 10);
    if (ret < 0)
    {
        return FAIL;
    }
    
    abs_x_max = (opr_buf[3] << 8) + opr_buf[2];
    abs_y_max = (opr_buf[5] << 8) + opr_buf[4];
        GTP_DEBUG("RES"); 
//        GTP_DEBUG("opr_buf：");
//        for (int i = 0; i < 10; i++)    {printf(" %d\n", opr_buf[i]);}    
        GTP_DEBUG_ARRAY(&opr_buf[0],10);

    opr_buf[0] = (uint8_t)((GTP_REG_CONFIG_DATA+6) >> 8);
    opr_buf[1] = (uint8_t)((GTP_REG_CONFIG_DATA+6) & 0xFF);

    ret = GTP_I2C_Read(GTP_ADDRESS, opr_buf, 3);
    if (ret < 0)
    {
        return FAIL;
    }
    int_trigger_type = opr_buf[7] & 0x03;
    
    GTP_INFO("X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
            abs_x_max,abs_y_max,int_trigger_type);
    
    return SUCCESS;    
}

/*******************************************************
Function:
    Initialize gtp.
Input:
    ts: goodix private data
Output:
    Executive outcomes.
        0: succeed, otherwise: failed
*******************************************************/
 int32_t GTP_Init_Panel(void)
{
    int32_t ret = -1;

    int32_t i = 0;
    uint16_t check_sum = 0;
    int32_t retry = 0;

    const uint8_t* cfg_info;
    uint8_t cfg_info_len  ;
        uint8_t* config;

    uint8_t cfg_num =0 ;        //需要配置的寄存器个数

    GTP_DEBUG_FUNC();
    
    I2C_Touch_Init();

    ret = GTP_I2C_Test();
    if (ret < 0)
    {
        GTP_ERROR("I2C communication ERROR!");
                return ret;
    }
        
        //获取触摸IC的型号
    GTP_Read_Version(); 
    
#if UPDATE_CONFIG

        config = (uint8_t *)malloc (GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH);

    if (config == NULL)
    {
      GTP_ERROR("malloc fail ! ");
      return -1;
    }
    
        config[0] = GTP_REG_CONFIG_DATA >> 8;
        config[1] =  GTP_REG_CONFIG_DATA & 0xff;
        
        //根据IC的型号指向不同的配置
        if(touchIC == GT917S)
        {
            cfg_info =  CTP_CFG_GT917S;//指向寄存器配置
            cfg_info_len = CFG_GROUP_LEN(CTP_CFG_GT917S) ;//计算配置表的大小
        }
        
    memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH);
    memcpy(&config[GTP_ADDR_LENGTH], cfg_info, cfg_info_len);
        
        cfg_num = cfg_info_len;
        
        GTP_DEBUG("cfg_info_len = %d ",cfg_info_len);
        GTP_DEBUG("cfg_num = %d ",cfg_num);
        GTP_DEBUG_ARRAY(config,6);
        
        /*根据LCD的扫描方向设置分辨率*/
        config[GTP_ADDR_LENGTH+1] = LCD_PIXEL_WIDTH & 0xFF;
        config[GTP_ADDR_LENGTH+2] = LCD_PIXEL_WIDTH >> 8;
        config[GTP_ADDR_LENGTH+3] = LCD_PIXEL_HEIGHT & 0xFF;
        config[GTP_ADDR_LENGTH+4] = LCD_PIXEL_HEIGHT >> 8;
        
        /*根据模式设置X2Y交换*/

    //不交换
        config[GTP_ADDR_LENGTH+6] &= ~(X2Y_LOC);

    //交换
    // config[GTP_ADDR_LENGTH+6] |= (X2Y_LOC);

    //计算要写入checksum寄存器的值
    check_sum = 0;

    /* 计算check sum校验值 */
    if(touchIC == GT917S) 
    {
      for (i = GTP_ADDR_LENGTH; i < (cfg_num+GTP_ADDR_LENGTH-3); i += 2) 
      {
        check_sum += (config[i] << 8) + config[i + 1];
      }
      check_sum = 0 - check_sum;
      GTP_DEBUG("Config checksum: 0x%04X", check_sum);
      //更新checksum
      config[(cfg_num+GTP_ADDR_LENGTH -3)] = (check_sum >> 8) & 0xFF;
      config[(cfg_num+GTP_ADDR_LENGTH -2)] = check_sum & 0xFF;
      config[(cfg_num+GTP_ADDR_LENGTH -1)] = 0x01;
    }
    
    // 写入配置信息

    for (retry = 0; retry < 5; retry++)
    {
        ret = GTP_I2C_Write(GTP_ADDRESS, config , cfg_num + GTP_ADDR_LENGTH+2);
        if (ret > 0)
        {
            break;
        }
    }
    Delay(0xfffff);                //延迟等待芯片更新
        

    
    
#if 1    //读出写入的数据，检查是否正常写入
    //检验读出的数据与写入的是否相同
    {
            uint16_t i;
            uint8_t buf[300];
             buf[0] = config[0];
             buf[1] =config[1];    //寄存器地址

            GTP_DEBUG_FUNC();

            ret = GTP_I2C_Read(GTP_ADDRESS, buf, sizeof(buf));
               
                    GTP_DEBUG("read ");

                    GTP_DEBUG_ARRAY(buf,cfg_num);
        
                    GTP_DEBUG("write ");

                    GTP_DEBUG_ARRAY(config,cfg_num);

                    //不对比版本号
            for(i=3;i<cfg_num+GTP_ADDR_LENGTH-3;i++)
            {

                if(config[i] != buf[i])
                {
                    GTP_ERROR("Config fail ! i = %d ",i);
//                            free(config);
//                    return -1;
                }
            }
            if(i==cfg_num+GTP_ADDR_LENGTH-3)
                GTP_DEBUG("Config success ! i = %d ",i);
    }
#endif
    free(config);

#endif
     /* emXGUI示例中不使能中断 */
    GTP_IRQ_Enable();
    
    GTP_Get_Info();

    return 0;
}


/*******************************************************
Function:
    Read chip version.
Input:
    client:  i2c device
    version: buffer to keep ic firmware version
Output:
    read operation return.
        2: succeed, otherwise: failed
*******************************************************/
int32_t GTP_Read_Version(void)
{
    int32_t ret = -1;
    uint8_t buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};    //寄存器地址

    GTP_DEBUG_FUNC();

    ret = GTP_I2C_Read(GTP_ADDRESS, buf, sizeof(buf));
    if (ret < 0)
    {
        GTP_ERROR("GTP read version failed");
        return ret;
    }

    if(buf[4] == '7')
    {
              //GT917S芯片
         GTP_INFO("IC2 Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
                
                if(buf[2] == '9' && buf[3] == '1' && buf[4] == '7' && buf[5] == 'S')
                {    
                    touchIC = GT917S; 
                    /* 设置当前的液晶屏类型 */
          //cur_lcd = INCH_5;    
                }                    
    }
    else 
       GTP_INFO("Unknown IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);

    return ret;
}

/*******************************************************
Function:
    I2c test Function.
Input:
    client:i2c client.
Output:
    Executive outcomes.
        2: succeed, otherwise failed.
*******************************************************/
static int8_t GTP_I2C_Test( void)
{
    uint8_t test[3] = {GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff};
    uint8_t retry = 0;
    int8_t ret = -1;

    GTP_DEBUG_FUNC();
  
    while(retry++ < 5)
    {
        ret = GTP_I2C_Read(GTP_ADDRESS, test, 3);
        if (ret > 0)
        {
            return ret;
        }
        GTP_ERROR("GTP i2c test failed time %d.",retry);
    }
    return ret;
}

//检测到触摸中断时调用，
void GTP_TouchProcess(void)
{
  GTP_DEBUG_FUNC();
  Goodix_TS_Work_Func();

}

#if 0//没有到的测试函数
/*******************************************************
Function:
    Request gpio(INT & RST) ports.
Input:
    ts: private data.
Output:
    Executive outcomes.
        >= 0: succeed, < 0: failed
*******************************************************/
static int8_t GTP_Request_IO_Port(struct goodix_ts_data *ts)
{
}

/*******************************************************
Function:
    Request interrupt.
Input:
    ts: private data.
Output:
    Executive outcomes.
        0: succeed, -1: failed.
*******************************************************/
static int8_t GTP_Request_IRQ(struct goodix_ts_data *ts)
{
}

//输出要初始化的数据及芯片中的真实数据
static void GT91xx_Config_Read_Proc(void)
{
    char temp_data[GTP_CONFIG_MAX_LENGTH + 2] = {0x80, 0x47};
    int i;

    GTP_INFO("==== GT9XX config init value====\n");

    for (i = 0 ; i < GTP_CONFIG_MAX_LENGTH ; i++)
    {
        printf("reg0x%x = 0x%02X ", i+0x8047, config[i + 2]);

        if (i % 10 == 9)
            printf("\n");
    }


    GTP_INFO("==== GT9XX config real value====\n");
    GTP_I2C_Read(GTP_ADDRESS, (uint8_t *)temp_data, GTP_CONFIG_MAX_LENGTH + 2);
    for (i = 0 ; i < GTP_CONFIG_MAX_LENGTH ; i++)
    {
        printf("reg0x%x = 0x%02X ", i+0x8047,temp_data[i+2]);

        if (i % 10 == 9)
            printf("\n");
    }

}

//向芯片写入配置数据
static int32_t GT91xx_Config_Write_Proc(void)
{
    int32_t ret = -1;

    int32_t i = 0;
    uint8_t check_sum = 0;
    int32_t retry = 0;
    uint8_t cfg_num =0x80FE-0x8047+1 ;        //需要配置的寄存器个数

    uint8_t cfg_info[] = CTP_CFG_GROUP1;
    uint8_t cfg_info_len =CFG_GROUP_LEN(cfg_info) ;

    GTP_INFO("==== GT9XX send config====\n");

    memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH);
    memcpy(&config[GTP_ADDR_LENGTH], cfg_info,cfg_info_len);

    //计算要写入checksum寄存器的值
    check_sum = 0;
    for (i = GTP_ADDR_LENGTH; i < cfg_num+GTP_ADDR_LENGTH; i++)
    {
        check_sum += config[i];
    }
    config[ cfg_num+GTP_ADDR_LENGTH] = (~check_sum) + 1;     //checksum
    config[ cfg_num+GTP_ADDR_LENGTH+1] =  1;                         //refresh 配置更新标志

    //写入配置信息
    for (retry = 0; retry < 5; retry++)
    {
        ret = GTP_I2C_Write(GTP_ADDRESS, config , cfg_num + GTP_ADDR_LENGTH+2);
        if (ret > 0)
        {
            break;
        }
    }


    return ret;
}

#endif

/**
  * @brief  触屏中断服务函数，emXGUI示例中没有使用中断
  * @param 无
  * @retval 无
  */
void GTP_IRQHandler(void)
{
    if(EXTI_GetITStatus(GTP_INT_EXTI_LINE) != RESET) //确保是否产生了EXTI Line中断
    {
        GTP_TouchProcess();    
        EXTI_ClearITPendingBit(GTP_INT_EXTI_LINE);     //清除中断标志位
    }  
}

/**
  * @brief  触屏检测函数，本函数作为emXGUI的定制检测函数，
   *        参考Goodix_TS_Work_Func修改而来， 只读取单个触摸点坐标
  * @param x[out] y[out] 读取到的坐标
  * @retval 坐标有效返回1，否则返回0
  */
int    GTP_Execu( int *x,int *y)
{
    uint8_t  end_cmd[3] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0};
    //2-寄存器地址 1-状态寄存器 8*1-每个触摸点使用8个寄存器 
    uint8_t  point_data[2 + 1 + 8 * 1 + 1]={GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF};
    uint8_t  touch_num = 0;
    uint8_t  finger = 0;

    uint8_t client_addr=GTP_ADDRESS;
    int32_t input_x = 0;
    int32_t input_y = 0;

    int32_t ret = -1;

    GTP_DEBUG_FUNC();

    ret = GTP_I2C_Read(client_addr, point_data, 12);//10字节寄存器加2字节地址
    if (ret < 0)
    {
        GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
        return 0;
    }
    
    finger = point_data[GTP_ADDR_LENGTH];//状态寄存器数据

    if (finger == 0x00)        //没有数据，退出
    {
        return 0;
    }

    if((finger & 0x80) == 0)//判断buffer status位
    {
        goto exit_work_func;//坐标未就绪，数据无效
    }

    touch_num = finger & 0x0f;//坐标点数
    if (touch_num > GTP_MAX_TOUCH)
    {
        goto exit_work_func;//大于最大支持点数，错误退出
    }    
  
    if (touch_num)
    {
//      id = point_data[0] & 0x0F;                                    //track id

      input_x  = point_data[3+1] | (point_data[3+2] << 8);    //x坐标
      input_y  = point_data[3+3] | (point_data[3+4] << 8);    //y坐标
//      input_w  = coor_data[5] | (coor_data[6] << 8);    //size

      if(input_x < GTP_MAX_WIDTH && input_y < GTP_MAX_HEIGHT)  
      {
        *x = input_x;
        *y = 480 - input_y;   // 交换一下y
      }
      else
      {
          //超出范围，错误退出
         goto exit_work_func;
      }
    }

exit_work_func:
    {
        //清空标志
        ret = GTP_I2C_Write(client_addr, end_cmd, 3);
        if (ret < 0)
        {
            GTP_INFO("I2C write end_cmd error!");
            return 0;
        }
    }

    return touch_num;
}
//MODULE_DESCRIPTION("GTP Series Driver");
//MODULE_LICENSE("GPL");

GT9XX.h

/* drivers/input/touchscreen/gt9xx.h
 * 
 * 2010 - 2013 Goodix Technology.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be a reference 
 * to you, when you are integrating the GOODiX's CTP IC into your system, 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 * General Public License for more details.
 * 
 */

#ifndef _GOODIX_GTXX_H
#define _GOODIX_GTXX_H

#include "stm32f10x.h"

#ifndef NULL
  #define NULL        0
#endif

#define LCD_PIXEL_HEIGHT    480
#define LCD_PIXEL_WIDTH     800

#define UPDATE_CONFIG    1    // 1 ：更新配置    0 ：不更新配置

/*flags的可取值，注释掉的在本工程没有用到*/
//#define I2C_M_TEN        0x0010    /* 表示这是个10位地址 */
//#define I2C_M_NOSTART        0x4000    /* if I2C_FUNC_PROTOCOL_MANGLING */
//#define I2C_M_REV_DIR_ADDR    0x2000    /* if I2C_FUNC_PROTOCOL_MANGLING */
//#define I2C_M_IGNORE_NAK    0x1000    /* if I2C_FUNC_PROTOCOL_MANGLING */
//#define I2C_M_NO_RD_ACK        0x0800    /* if I2C_FUNC_PROTOCOL_MANGLING */
//#define I2C_M_RECV_LEN        0x0400    /* length will be first received byte */

/* 表示读数据 */ 
#define I2C_M_RD        0x0001    
 /*
 * 存储I2C通讯的信息
 * @addr：  从设备的I2C设备地址    
 * @flags: 控制标志
 * @len：  读写数据的长度
 * @buf：  存储读写数据的指针
 **/
struct i2c_msg {
    uint8_t addr;        /*从设备的I2C设备地址 */
    uint16_t flags;    /*控制标志*/
    uint16_t len;        /*读写数据的长度            */
    uint8_t *buf;        /*存储读写数据的指针    */
};



/** 
  * @brief 触摸屏参数
  */
typedef struct
{
  /*根据触摸屏类型配置*/
  uint16_t max_width;  //触点最大值,高
  uint16_t max_height;  //触点最大值，宽

  uint16_t config_reg_addr;      //不同类型的触摸ic配置寄存器地址不同

}TOUCH_PARAM_TypeDef;

/** 
  * @brief  触摸屏类型
  */ 
typedef enum 
{
    GT917S=0,
}TOUCH_IC;

extern TOUCH_IC touchIC;
extern const TOUCH_PARAM_TypeDef touch_param[];

// STEP_3(optional): Specify your special config info if needed
#define GTP_MAX_HEIGHT   touch_param[touchIC].max_height
#define GTP_MAX_WIDTH    touch_param[touchIC].max_width
#define GTP_INT_TRIGGER  0
#define GTP_MAX_TOUCH         5


//***************************PART3:OTHER define*********************************
#define GTP_DRIVER_VERSION          "V2.2<2014/01/14>"
#define GTP_I2C_NAME                "Goodix-TS"
#define GT91XX_CONFIG_PROC_FILE     "gt9xx_config"
#define GTP_POLL_TIME         10    
#define GTP_ADDR_LENGTH       2
#define GTP_CONFIG_MIN_LENGTH 186
#define GTP_CONFIG_MAX_LENGTH 256
#define FAIL                  0
#define SUCCESS               1
#define SWITCH_OFF            0
#define SWITCH_ON             1

//******************** For GT9XXF Start **********************//
#define GTP_REG_BAK_REF                 0x99D0
#define GTP_REG_MAIN_CLK                0x8020
#define GTP_REG_CHIP_TYPE               0x8000
#define GTP_REG_HAVE_KEY                0x804E
#define GTP_REG_MATRIX_DRVNUM           0x8069     
#define GTP_REG_MATRIX_SENNUM           0x806A
#define GTP_REG_COMMAND                0x8040

#define GTP_COMMAND_READSTATUS        0
#define GTP_COMMAND_DIFFERENCE        1
#define GTP_COMMAND_SOFTRESET            2
#define GTP_COMMAND_UPDATE                3
#define GTP_COMMAND_CALCULATE        4
#define GTP_COMMAND_TURNOFF            5




#define GTP_FL_FW_BURN              0x00
#define GTP_FL_ESD_RECOVERY         0x01
#define GTP_FL_READ_REPAIR          0x02

#define GTP_BAK_REF_SEND                0
#define GTP_BAK_REF_STORE               1
#define CFG_LOC_DRVA_NUM                29
#define CFG_LOC_DRVB_NUM                30
#define CFG_LOC_SENS_NUM                31

#define GTP_CHK_FW_MAX                  40
#define GTP_CHK_FS_MNT_MAX              300
#define GTP_BAK_REF_PATH                "/data/gtp_ref.bin"
#define GTP_MAIN_CLK_PATH               "/data/gtp_clk.bin"
#define GTP_RQST_CONFIG                 0x01
#define GTP_RQST_BAK_REF                0x02
#define GTP_RQST_RESET                  0x03
#define GTP_RQST_MAIN_CLOCK             0x04
#define GTP_RQST_RESPONDED              0x00
#define GTP_RQST_IDLE                   0xFF

//******************** For GT9XXF End **********************//
// Registers define
#define GTP_READ_COOR_ADDR    0x814E
#define GTP_REG_SLEEP         0x8040
#define GTP_REG_SENSOR_ID     0x814A
#define GTP_REG_CONFIG_DATA   touch_param[touchIC].config_reg_addr
#define GTP_REG_VERSION       0x8140

#define RESOLUTION_LOC        3
#define TRIGGER_LOC           8
#define X2Y_LOC                        (1<<3)

#define CFG_GROUP_LEN(p_cfg_grp)  (sizeof(p_cfg_grp) / sizeof(p_cfg_grp[0]))
    

//***************************PART1:ON/OFF define*******************************

#define GTP_DEBUG_ON             1
#define GTP_DEBUG_ARRAY_ON    1
#define GTP_DEBUG_FUNC_ON       0
// Log define
#define GTP_INFO(fmt,arg...)           printf("<<-GTP-INFO->> "fmt"\n",##arg)
#define GTP_ERROR(fmt,arg...)          printf("<<-GTP-ERROR->> "fmt"\n",##arg)
#define GTP_DEBUG(fmt,arg...)          do{\
                                         if(GTP_DEBUG_ON)\
                                         printf("<<-GTP-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
                                                                                    }while(0)

#define GTP_DEBUG_ARRAY(array, num)    do{\
                                         int32_t i;\
                                         uint8_t* a = array;\
                                         if(GTP_DEBUG_ARRAY_ON)\
                                         {\
                                            printf("<<-GTP-DEBUG-ARRAY->>\n");\
                                            for (i = 0; i < (num); i++)\
                                            {\
                                                printf("%02x   ", (a)[i]);\
                                                if ((i + 1 ) %10 == 0)\
                                                {\
                                                    printf("\n");\
                                                }\
                                            }\
                                            printf("\n");\
                                        }\
                                       }while(0)

#define GTP_DEBUG_FUNC()               do{\
                                         if(GTP_DEBUG_FUNC_ON)\
                                         printf("<<-GTP-FUNC->> Func:%s@Line:%d\n",__func__,__LINE__);\
                                       }while(0)

                                                                             
                                                                             
#define GTP_SWAP(x, y)                 do{\
                                         typeof(x) z = x;\
                                         x = y;\
                                         y = z;\
                                       }while (0)

//*****************************End of Part III********************************
int8_t GTP_Reset_Guitar(void);
int32_t GTP_Read_Version(void);
void GTP_IRQ_Disable(void);
void GTP_IRQ_Enable(void);
int32_t GTP_Init_Panel(void);
int8_t GTP_Send_Command(uint8_t command);
int    GTP_Execu( int *x,int *y);                                       

#endif /* _GOODIX_GT9XX_H_ */

bsp_i2c_touch.c

/**
  ******************************************************************************
  * @file    bsp_i2c_ee.c
  * @author  STMicroelectronics
  * @version V1.0
  * @date    2015-xx-xx
  * @brief   电容触摸屏的专用iic驱动
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火  STM32 F407 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 

#include "bsp_i2c_touch.h"
#include "core_delay.h"   
#include "bsp_usart.h"


/* STM32 I2C 快速模式 */
#define I2C_Speed              400000

/* 这个地址只要与STM32外挂的I2C器件地址不一样即可 */
#define I2C_OWN_ADDRESS7      0x0A



//static void Delay(__IO uint32_t nCount)     //简单的延时函数
//{
//    for(; nCount != 0; nCount--);
//}


/**
  * @brief  使能触摸屏中断
  * @param  无
  * @retval 无
  */
void I2C_GTP_IRQEnable(void)
{
  EXTI_InitTypeDef EXTI_InitStructure;  
  NVIC_InitTypeDef NVIC_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;  
  /*配置 INT 为浮空输入 */   
  GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);  
  
  /* 连接 EXTI 中断源 到INT 引脚 */
  GPIO_EXTILineConfig(GTP_INT_EXTI_PORTSOURCE, GTP_INT_EXTI_PINSOURCE);

  /* 选择 EXTI 中断源 */
  EXTI_InitStructure.EXTI_Line = GTP_INT_EXTI_LINE;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;  
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);  
  
  /* 配置中断优先级 */
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
  
    /*使能中断*/
  NVIC_InitStructure.NVIC_IRQChannel = GTP_INT_EXTI_IRQ;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

}

/**
  * @brief  关闭触摸屏中断
  * @param  无
  * @retval 无
  */
void I2C_GTP_IRQDisable(void)
{
  EXTI_InitTypeDef EXTI_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  /*配置 INT 为浮空输入 */   
  GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);

  /* 连接 EXTI 中断源 到INT 引脚 */
  GPIO_EXTILineConfig(GTP_INT_EXTI_PORTSOURCE, GTP_INT_EXTI_PINSOURCE);

  /* 选择 EXTI 中断源 */
  EXTI_InitStructure.EXTI_Line = GTP_INT_EXTI_LINE;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd = DISABLE;
  EXTI_Init(&EXTI_InitStructure);

  /* 配置中断优先级 */
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

  /* 关闭中断 */
  NVIC_InitStructure.NVIC_IRQChannel = GTP_INT_EXTI_IRQ;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
  NVIC_Init(&NVIC_InitStructure);

}

/**
  * @brief  触摸屏 I/O配置
  * @param  无
  * @retval 无
  */
static void I2C_GPIO_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;  
  
  /*使能触摸屏使用的引脚的时钟*/
  RCC_APB2PeriphClockCmd(GTP_I2C_SCL_GPIO_CLK|
                            GTP_I2C_SDA_GPIO_CLK|
                           GTP_RST_GPIO_CLK|GTP_INT_GPIO_CLK, 
                           ENABLE);

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    
  /*配置SCL引脚 */   
  GPIO_InitStructure.GPIO_Pin = GTP_I2C_SCL_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GTP_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);

  /*配置SDA引脚 */
  GPIO_InitStructure.GPIO_Pin = GTP_I2C_SDA_PIN;
  GPIO_Init(GTP_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
 
  /*配置RST引脚，推挽输出 */   
  GPIO_InitStructure.GPIO_Pin = GTP_RST_GPIO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GTP_RST_GPIO_PORT, &GPIO_InitStructure);
  
  /*配置 INT引脚，推挽输出，方便初始化 */   
  GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    //设置为下拉，方便初始化
  GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);
}


/**
  * @brief  对GT91xx芯片进行复位
  * @param  无
  * @retval 无
  */
void I2C_ResetChip(void)
{
      GPIO_InitTypeDef GPIO_InitStructure;

    /*配置 INT引脚，下拉推挽输出，方便初始化 */   
      GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //设置为下拉，方便初始化
      GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);

      /*初始化GT5688,rst为高电平，int为低电平，则gt5688的设备地址被配置为0xBA*/
    GPIO_ResetBits (GTP_INT_GPIO_PORT,GTP_INT_GPIO_PIN);
      /*复位为低电平，为初始化做准备*/
      GPIO_ResetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
//      Delay_us(200);
//    Delay(1);
    Delay_ms(1);

      /*拉高一段时间，进行初始化*/
      GPIO_SetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
      Delay_ms(55);

      /*把INT引脚设置为浮空输入模式，以便接收触摸中断信号*/
      GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);
}

/**
  * @brief  I2C 外设(GT5xx)初始化
  * @param  无
  * @retval 无
  */
void I2C_Touch_Init(void)
{
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
  
  I2C_GPIO_Config(); 
 
  I2C_ResetChip();

  I2C_GTP_IRQDisable();
}
/*
*********************************************************************************************************
*    函 数 名: i2c_Delay
*    功能说明: I2C总线位延迟，最快400KHz
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
static void i2c_Delay(void)
{
    uint8_t i;

    /*　
         下面的时间是通过逻辑分析仪测试得到的。
    工作条件：CPU主频180MHz ，MDK编译环境，1级优化
      
        循环次数为50时，SCL频率 = 333KHz 
        循环次数为30时，SCL频率 = 533KHz，  
         循环次数为20时，SCL频率 = 727KHz， 
  */
    for (i = 0; i < 50; i++);
//  Delay_us(40);
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Start
*    功能说明: CPU发起I2C总线启动信号
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Start(void)
{
    /* 当SCL高电平时，SDA出现一个下跳沿表示I2C总线启动信号 */
    I2C_SDA_1();
    I2C_SCL_1();
    i2c_Delay();
    I2C_SDA_0();
    i2c_Delay();
    I2C_SCL_0();
    i2c_Delay();
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Start
*    功能说明: CPU发起I2C总线停止信号
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Stop(void)
{
    /* 当SCL高电平时，SDA出现一个上跳沿表示I2C总线停止信号 */
    I2C_SDA_0();
    I2C_SCL_1();
    i2c_Delay();
    I2C_SDA_1();
}

/*
*********************************************************************************************************
*    函 数 名: i2c_SendByte
*    功能说明: CPU向I2C总线设备发送8bit数据
*    形    参：_ucByte ： 等待发送的字节
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_SendByte(uint8_t _ucByte)
{
    uint8_t i;

    /* 先发送字节的高位bit7 */
    for (i = 0; i < 8; i++)
    {        
        if (_ucByte & 0x80)
        {
            I2C_SDA_1();
        }
        else
        {
            I2C_SDA_0();
        }
        i2c_Delay();
        I2C_SCL_1();
        i2c_Delay();    
        I2C_SCL_0();
        if (i == 7)
        {
             I2C_SDA_1(); // 释放总线
        }
        _ucByte <<= 1;    /* 左移一个bit */
        i2c_Delay();
    }
}

/*
*********************************************************************************************************
*    函 数 名: i2c_ReadByte
*    功能说明: CPU从I2C总线设备读取8bit数据
*    形    参：无
*    返 回 值: 读到的数据
*********************************************************************************************************
*/
uint8_t i2c_ReadByte(void)
{
    uint8_t i;
    uint8_t value;

    /* 读到第1个bit为数据的bit7 */
    value = 0;
    for (i = 0; i < 8; i++)
    {
        value <<= 1;
        I2C_SCL_1();
        i2c_Delay();
        if (I2C_SDA_READ())
        {
            value++;
        }
        I2C_SCL_0();
        i2c_Delay();
    }
    return value;
}

/*
*********************************************************************************************************
*    函 数 名: i2c_WaitAck
*    功能说明: CPU产生一个时钟，并读取器件的ACK应答信号
*    形    参：无
*    返 回 值: 返回0表示正确应答，1表示无器件响应
*********************************************************************************************************
*/
uint8_t i2c_WaitAck(void)
{
    uint8_t re;

    I2C_SDA_1();    /* CPU释放SDA总线 */
    i2c_Delay();
    I2C_SCL_1();    /* CPU驱动SCL = 1, 此时器件会返回ACK应答 */
    i2c_Delay();
    if (I2C_SDA_READ())    /* CPU读取SDA口线状态 */
    {
        re = 1;
    }
    else
    {
        re = 0;
    }
    I2C_SCL_0();
    i2c_Delay();
    return re;
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Ack
*    功能说明: CPU产生一个ACK信号
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Ack(void)
{
    I2C_SDA_0();    /* CPU驱动SDA = 0 */
    i2c_Delay();
    I2C_SCL_1();    /* CPU产生1个时钟 */
    i2c_Delay();
    I2C_SCL_0();
    i2c_Delay();
    I2C_SDA_1();    /* CPU释放SDA总线 */
}

/*
*********************************************************************************************************
*    函 数 名: i2c_NAck
*    功能说明: CPU产生1个NACK信号
*    形    参：无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_NAck(void)
{
    I2C_SDA_1();    /* CPU驱动SDA = 1 */
    i2c_Delay();
    I2C_SCL_1();    /* CPU产生1个时钟 */
    i2c_Delay();
    I2C_SCL_0();
    i2c_Delay();    
}



#define I2C_DIR_WR    0        /* 写控制bit */
#define I2C_DIR_RD    1        /* 读控制bit */

/**
  * @brief   使用IIC读取数据
  * @param   
  *     @arg ClientAddr:从设备地址
  *        @arg pBuffer:存放由从机读取的数据的缓冲区指针
  *        @arg NumByteToRead:读取的数据长度
  * @retval  无
  */
uint32_t I2C_ReadBytes(uint8_t ClientAddr,uint8_t* pBuffer, uint16_t NumByteToRead)
{
    
    /* 第1步：发起I2C总线启动信号 */
    i2c_Start();
    
    /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
    i2c_SendByte(ClientAddr | I2C_DIR_RD);    /* 此处是读指令 */
    
    /* 第3步：等待ACK */
    if (i2c_WaitAck() != 0)
    {
        goto cmd_fail;    /* 器件无应答 */
    }

    while(NumByteToRead) 
  {
    *pBuffer = i2c_ReadByte();
    
    if(NumByteToRead == 1)
    {
            i2c_NAck();    /* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
      
      /* 发送I2C总线停止信号 */
      i2c_Stop();
    }
    
    /* 读指针自增 */
    pBuffer++; 
      
    /*计数器自减 */
    NumByteToRead--;
    
    i2c_Ack();    /* 中间字节读完后，CPU产生ACK信号(驱动SDA = 0) */  
  }

    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 0;    /* 执行成功 */

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 1;
}

/**
  * @brief   使用IIC写入数据
  * @param   
  *     @arg ClientAddr:从设备地址
  *        @arg pBuffer:缓冲区指针
  *     @arg NumByteToWrite:写的字节数
  * @retval  无
  */
uint32_t I2C_WriteBytes(uint8_t ClientAddr,uint8_t* pBuffer,  uint8_t NumByteToWrite)
{
    uint16_t m;    

  /*　第0步：发停止信号，启动内部写操作　*/
  i2c_Stop();
  
  /* 通过检查器件应答的方式，判断内部写操作是否完成, 一般小于 10ms             
    CLK频率为200KHz时，查询次数为30次左右
  */
  for (m = 0; m < 1000; m++)
  {                
    /* 第1步：发起I2C总线启动信号 */
    i2c_Start();
    
    /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
    i2c_SendByte(ClientAddr | I2C_DIR_WR);    /* 此处是写指令 */
    
    /* 第3步：发送一个时钟，判断器件是否正确应答 */
    if (i2c_WaitAck() == 0)
    {
      break;
    }
  }
  if (m  == 1000)
  {
    goto cmd_fail;    /* EEPROM器件写超时 */
  }    
    
  while(NumByteToWrite--)
  {
    /* 第4步：开始写入数据 */
    i2c_SendByte(*pBuffer);
  //printf(" 0x%x\r\n", *pBuffer);
    /* 第5步：检查ACK */
    if (i2c_WaitAck() != 0)
    {
      goto cmd_fail;    /* 器件无应答 */
    }
  
      pBuffer++;    /* 地址增1 */        
  }
    
    /* 命令执行成功，发送I2C总线停止信号 */
    i2c_Stop();
    return 0;

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 1;
}


/*********************************************END OF FILE**********************/

bsp_i2c_touch.h

#ifndef __I2C_TOUCH_H
#define    __I2C_TOUCH_H

#include "stm32f10x.h"

/*设定使用的电容屏IIC设备地址*/
#define GTP_ADDRESS            0xBA

#define I2CT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define I2CT_LONG_TIMEOUT         ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))

/*I2C引脚*/
#define GTP_I2C_SCL_PIN                  GPIO_Pin_10                 
#define GTP_I2C_SCL_GPIO_PORT            GPIOF                     
#define GTP_I2C_SCL_GPIO_CLK             RCC_APB2Periph_GPIOF
#define GTP_I2C_SCL_SOURCE               GPIO_PinSource10

#define GTP_I2C_SDA_PIN                  GPIO_Pin_6                 
#define GTP_I2C_SDA_GPIO_PORT            GPIOF                    
#define GTP_I2C_SDA_GPIO_CLK             RCC_APB2Periph_GPIOF
#define GTP_I2C_SDA_SOURCE               GPIO_PinSource6

/*复位引脚*/
#define GTP_RST_GPIO_PORT                GPIOF
#define GTP_RST_GPIO_CLK                 RCC_APB2Periph_GPIOF
#define GTP_RST_GPIO_PIN                 GPIO_Pin_11
/*中断引脚*/
#define GTP_INT_GPIO_PORT                GPIOF
#define GTP_INT_GPIO_CLK                 RCC_APB2Periph_GPIOF
#define GTP_INT_GPIO_PIN                 GPIO_Pin_9
#define GTP_INT_EXTI_PORTSOURCE          GPIO_PortSourceGPIOF
#define GTP_INT_EXTI_PINSOURCE           GPIO_PinSource9
#define GTP_INT_EXTI_LINE                EXTI_Line9
#define GTP_INT_EXTI_IRQ                 EXTI9_5_IRQn
/*中断服务函数*/
#define GTP_IRQHandler                   EXTI9_5_IRQHandler


//软件IIC使用的宏
#define I2C_SCL_1()  GPIO_SetBits(GTP_I2C_SCL_GPIO_PORT, GTP_I2C_SCL_PIN)        /* SCL = 1 */
#define I2C_SCL_0()  GPIO_ResetBits(GTP_I2C_SCL_GPIO_PORT, GTP_I2C_SCL_PIN)        /* SCL = 0 */

#define I2C_SDA_1()  GPIO_SetBits(GTP_I2C_SDA_GPIO_PORT, GTP_I2C_SDA_PIN)        /* SDA = 1 */
#define I2C_SDA_0()  GPIO_ResetBits(GTP_I2C_SDA_GPIO_PORT, GTP_I2C_SDA_PIN)        /* SDA = 0 */

#define I2C_SDA_READ()  GPIO_ReadInputDataBit(GTP_I2C_SDA_GPIO_PORT, GTP_I2C_SDA_PIN)    /* 读SDA口线状态 */

//函数接口
void I2C_Touch_Init(void);
uint32_t I2C_WriteBytes(uint8_t ClientAddr,uint8_t* pBuffer,  uint8_t NumByteToWrite);
uint32_t I2C_ReadBytes(uint8_t ClientAddr,uint8_t* pBuffer, uint16_t NumByteToRead);
void I2C_ResetChip(void);
void I2C_GTP_IRQDisable(void);
void I2C_GTP_IRQEnable(void);

#endif /* __I2C_TOUCH_H */

主要部分就这些，实测能用（野火霸道开发板测试）。

测试结果：