devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用电容触摸屏做画板——软件IIC（二）_触摸iic

作者：Cpp五条 | 2024-05-19 17:55:37

赞

踩

触摸iic

使用电容触摸屏时发现硬件IIC会使电容触摸屏卡死，经过调试发现软件IIC更加好用，那么下面就了解一下软件IIC叭。

IIC协议：

  1. //先定义引脚的高低电平
  2. #define IIC_SDA_1   GPIO_SetBits(EEPROM_I2C_SDA_GPIO_PORT,EEPROM_I2C_SDA_PIN)
  3. #define IIC_SDA_0   GPIO_ResetBits(EEPROM_I2C_SDA_GPIO_PORT,EEPROM_I2C_SDA_PIN)
  4.  
  5. #define IIC_SCL_1   GPIO_SetBits(EEPROM_I2C_SCL_GPIO_PORT,EEPROM_I2C_SCL_PIN)
  6. #define IIC_SCL_0   GPIO_ResetBits(EEPROM_I2C_SCL_GPIO_PORT,EEPROM_I2C_SCL_PIN)
  7.  
  8. //由于是在IIC读写EEPROM那边改的，所以引脚的宏并没有改

那么就模拟起始信号写 一个引脚电平的变换：

  1. static void  IIC_Start(void)
  2. {
  3.     IIC_SDA_1;		//保持高电平
  4.     IIC_SCL_1;
  5.   
  6.     IIC_Delay();	//延迟
  7.   
  8.     IIC_SDA_0;		//SDA低电平，起始信号
  9.     IIC_Delay();
  10.     
  11.     IIC_SCL_0;		//SCL低电平，开始工作
  12.     IIC_Delay();
  13.  
  14. }

其中的延时函数：

  1. void IIC_Delay(void)
  2. {
  3.   uint8_t i ;  
  4.   for(i=0;i<50;i++);  
  5. }

（2）模拟停止信号：SCL为高电平，SDA由低电平变为高电平。

  1. static void  IIC_Stop(void)
  2. {
  3.     IIC_SDA_0;
  4.     IIC_SCL_1;
  5.   
  6.     IIC_Delay();
  7.   
  8.     IIC_SDA_1;
  9.     IIC_Delay();
  10.     
  11.     IIC_SCL_1;
  12.     IIC_Delay();
  13.  
  14. }

（3）数据有效时读取数据：SCL高电平、读取SDA数据

每次采样一个字节一共八位，当SCL高电平时，SDA为高电平时数据有效。

  1. //定义一个读取引脚的宏
  2. #define IIC_READ_SDA()  GPIO_ReadInputDataBit(EEPROM_I2C_SDA_GPIO_PORT,EEPROM_I2C_SDA_PIN)

 读取数据函数：

  1. static uint8_t IIC_ReadByte(void)
  2. {
  3.   uint8_t i;  
  4.   uint8_t value = 0;
  5.   
  6.   for(i=0;i<8;i++)
  7.   {
  8.     //要将高位的数据往左移
  9.     value <<= 1 ;    
  10.     
  11.     IIC_SCL_1;
  12.     IIC_Delay();
  13.  
  14.     if(IIC_READ_SDA())  //SDA为高电平时数据有效
  15.     {
  16.       value++;
  17.     }
  18.     else
  19.     {
  20.     
  21.     }        
  22. 	
  23.     //读取一个字节后要变为低电平
  24.     IIC_SCL_0;      
  25.     IIC_Delay(); 
  26.     
  27.   }
  28.   
  29.   return value;
  30. }

（4）发送一个数据：收发的电平信号与读取一样。

  1. static void IIC_SendByte(uint8_t data)
  2. {
  3.   uint8_t i;  
  4.   
  5.   for(i=0;i<8;i++)
  6.   {   
  7.     //每一次先发高位数据
  8.     if(data &0x80)
  9.     {
  10.        IIC_SDA_1;
  11.     }
  12.     else
  13.     {
  14.       IIC_SDA_0;
  15.     }   
  16.     IIC_Delay();     
  17.     
  18.     //拉高一段时间
  19.     IIC_SCL_1;
  20.     IIC_Delay();     
  21.     //再拉低   
  22.     IIC_SCL_0;      
  23.     IIC_Delay(); 
  24.     //将数据左移使其置为高位
  25.     data <<= 1 ;    
  26.     
  27.     //释放总线
  28.     if(i==7)
  29.     {
  30.       //相当于产生一个停止信号
  31.       IIC_SDA_1;
  32.     }
  33.     
  34.   }  
  35.  
  36. }

（5）发送非应答/应答信号：当SCL处于一个高电平的时钟里面，等待响应，当SDA表现为高电平时，表现为非应答信号。

  1. static void IIC_NACK(void)
  2. {
  3.   IIC_SDA_1;
  4.   IIC_Delay();     
  5.   
  6.   IIC_SCL_1;
  7.   IIC_Delay();  
  8.   IIC_SCL_0;
  9.   
  10.   IIC_Delay(); 
  11.  
  12. }

当SCL处于一个高电平的时钟里面，等待响应，当SDA表现为低电平时，表现为应答信号。

  1. static void IIC_ACK(void)
  2. {
  3.   IIC_SDA_0;
  4.   IIC_Delay();     
  5.   
  6.   IIC_SCL_1;
  7.   IIC_Delay();  
  8.   IIC_SCL_0;
  9.   
  10.   IIC_Delay(); 
  11.   
  12.   //释放总线
  13.   IIC_SDA_1;
  14. }

 （6）等待应答信号

  1. static uint8_t IIC_Wait_ACK(void)
  2. {
  3.   uint8_t ack_value;
  4.   //释放控制权
  5.   IIC_SDA_1;
  6.   IIC_Delay(); 
  7.   //拉高进行读取
  8.   IIC_SCL_1;  
  9.   IIC_Delay(); 
  10.   //判断应答还是非应答
  11.   if(IIC_READ_SDA())
  12.     ack_value = 1;
  13.   else
  14.     ack_value = 0;
  15.   
  16.   IIC_SCL_0;      
  17.   IIC_Delay();  
  18.   
  19.   return ack_value;
  20. }

接下来使用软件IIC控制液晶屏：

一、初始化引脚

 

 对所有要使用的引脚进行初始化：

  1. /*设定使用的电容屏 IIC 设备地址*/
  2. #define GTP_ADDRESS 0xBA
  3.  
  4. #define I2CT_FLAG_TIMEOUT ((uint32_t)0x1000)
  5. #define I2CT_LONG_TIMEOUT ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))
  6.  
  7. /*I2C 引脚*/
  8. #define GTP_I2C I2C2
  9. #define GTP_I2C_CLK RCC_APB1Periph_I2C2
  10. #define GTP_I2C_CLK_INIT RCC_APB1PeriphClockCmd
  11.  
  12. #define GTP_I2C_SCL_PIN GPIO_Pin_4
  13. #define GTP_I2C_SCL_GPIO_PORT GPIOH
  14. #define GTP_I2C_SCL_GPIO_CLK RCC_AHB1Periph_GPIOH
  15. #define GTP_I2C_SCL_SOURCE GPIO_PinSource4
  16. #define GTP_I2C_SCL_AF GPIO_AF_I2C2
  17.  
  18. #define GTP_I2C_SDA_PIN GPIO_Pin_5
  19. #define GTP_I2C_SDA_GPIO_PORT GPIOH
  20. #define GTP_I2C_SDA_GPIO_CLK RCC_AHB1Periph_GPIOH
  21. #define GTP_I2C_SDA_SOURCE GPIO_PinSource5
  22. #define GTP_I2C_SDA_AF GPIO_AF_I2C2
  23.  
  24. /*复位引脚*/
  25. #define GTP_RST_GPIO_PORT GPIOI
  26. #define GTP_RST_GPIO_CLK RCC_AHB1Periph_GPIOI
  27. #define GTP_RST_GPIO_PIN GPIO_Pin_8
  28. /*中断引脚*/
  29. #define GTP_INT_GPIO_PORT GPIOD
  30. #define GTP_INT_GPIO_CLK RCC_AHB1Periph_GPIOD
  31. #define GTP_INT_GPIO_PIN GPIO_Pin_13
  32. #define GTP_INT_EXTI_PORTSOURCE EXTI_PortSourceGPIOD
  33. #define GTP_INT_EXTI_PINSOURCE EXTI_PinSource13
  34. #define GTP_INT_EXTI_LINE EXTI_Line13
  35. #define GTP_INT_EXTI_IRQ EXTI15_10_IRQn
  36. /*中断服务函数*/
  37. #define GTP_IRQHandler EXTI15_10_IRQHandler
  38.  
  39. //初始化触摸屏使用的I2C信号线，并且把RET与INT引脚也初始化为下拉推挽输出模式，以便刚上电的时候输出上电时序，设置触摸屏的I2C设备地址
  40. static void I2C_GPIO_Config(void)
  41. {
  42.   GPIO_InitTypeDef GPIO_InitStructure;  
  43.    
  44.   /*使能IIC时钟 */
  45.   RCC_APB1PeriphClockCmd(GTP_I2C_CLK, ENABLE);
  46.   
  47.   /*使能触摸屏使用的引脚的时钟 */
  48.   RCC_AHB1PeriphClockCmd(GTP_I2C_SCL_GPIO_CLK | 	GTP_I2C_SDA_GPIO_CLK|GTP_RST_GPIO_CLK|GTP_INT_GPIO_CLK, ENABLE);
  49.  
  50.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
  51.     
  52.       /* 配置I2C_SCL源*/
  53.     GPIO_PinAFConfig(GTP_I2C_SCL_GPIO_PORT, 
  54.                      GTP_I2C_SCL_SOURCE, GTP_I2C_SCL_AF);
  55.     /* 配置I2C_SDA 源*/
  56.     GPIO_PinAFConfig(GTP_I2C_SDA_GPIO_PORT, 
  57.                      GTP_I2C_SDA_SOURCE, GTP_I2C_SDA_AF);  
  58.     
  59.       /*配置SCL引脚 */   
  60.     GPIO_InitStructure.GPIO_Pin = GTP_I2C_SCL_PIN;
  61.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  62.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  63.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  64.     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  65.     GPIO_Init(GTP_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);
  66.  
  67.     /*配置SDA引脚 */
  68.     GPIO_InitStructure.GPIO_Pin = GTP_I2C_SDA_PIN;
  69.     GPIO_Init(GTP_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
  70.     
  71.       /*!< Configure RST */   
  72.   GPIO_InitStructure.GPIO_Pin = GTP_RST_GPIO_PIN;
  73.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  74.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  75.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  76.   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
  77.   GPIO_Init(GTP_RST_GPIO_PORT, &GPIO_InitStructure);
  78.   
  79.   /*!< Configure INT */   
  80.   GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  81.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  82.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  83.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  84.   GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;       //设置为下拉，方便初始化
  85.   GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);

通过RST引脚与INT引脚确定设备地址以及配置IIC模式：最开始这INT引脚要配置为输出模式，后面要输入，实现对液晶屏的上电时序控制。

  1. void I2C_ResetChip(void)
  2. {
  3. 	  GPIO_InitTypeDef GPIO_InitStructure;
  4.  
  5. 	  /*!< Configure INT */
  6. 	  GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  7. 	  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  8. 	  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  9. 	  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  10. 	  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;       //设置为下拉，方便初始化
  11. 	  GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);
  12.  
  13. 	  /*初始化GT9157,rst为高电平，int为低电平，则gt9157的设备地址被配置为0xBA*/
  14. 	  //这段函数中控制RST引脚由低电平改变至高电平，且期间按INT引脚一直为低电平这样的上电时序使控制芯片的I2C写地址为0xBA，读地址为0xBB，可以写为（0xBA|0x01）
  15. 	  /*复位为低电平，为初始化做准备*/
  16. 	  GPIO_ResetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
  17. 	  Delay(0x0FFFFF);
  18.  
  19. 	  /*拉高一段时间，进行初始化*/
  20. 	  GPIO_SetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
  21. 	  Delay(0x0FFFFF);
  22.  
  23. 	  /*把INT引脚设置为浮空输入模式*/
  24. 	  /*!< Configure INT */
  25.       //使其可以接收触控芯片输出的触摸中断信号
  26. 	  GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  27. 	  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  28. 	  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  29. 	  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
  30. 	  GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);
  31. }

配置中断：

  1. //INT引脚配置为上升沿触发
  2. void I2C_GTP_IRQEnable(void)
  3. {
  4.         EXTI_InitTypeDef EXTI_InitStructure;
  5.         NVIC_InitTypeDef NVIC_InitStructure;
  6.         /*配置 INT 为浮空输入 */
  7.         GPIO_InitStructure.GPIO_Pin = GTP_INT_GPIO_PIN;
  8.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  9.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  10.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  11.         GPIO_Init(GTP_INT_GPIO_PORT, &GPIO_InitStructure);
  12.  
  13.         /* 连接 EXTI 中断源 到 INT 引脚 */
  14.         SYSCFG_EXTILineConfig(GTP_INT_EXTI_PORTSOURCE, GTP_INT_EXTI_PINSOURCE);
  15.  
  16.         /* 选择 EXTI 中断源 */
  17.         EXTI_InitStructure.EXTI_Line = GTP_INT_EXTI_LINE;
  18.         EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  19.         EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  20.         EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  21.         EXTI_Init(&EXTI_InitStructure);
  22.  
  23.         /* 配置中断优先级 */
  24.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1)
  25.         /*使能中断*/
  26.         NVIC_InitStructure.NVIC_IRQChannel = GTP_INT_EXTI_IRQ;
  27.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  28.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  29.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  30.         NVIC_Init(&NVIC_InitStructure);
  31. }
  1. void SysTick_Handler(void)
  2. {
  3.  
  4. 	static uint8_t timecount=0;
  5. 	if(timecount>=10)
  6. 	{
  7. 		timecount=0;
  8. 		GTP_TouchProcess();
  9. 	}
  10. 	TimingDelay_Decrement();
  11. 	timecount++;
  12. }

这个中断用于触摸处理。具体的函数是在gt9xx.c文件中，是触摸屏基于Linux给的一个驱动文件，函数作用用于判断现在触摸点于哪个位置。

配置I2C模式，FT9157使用的是标准7位地址模式的I2C通讯：

  1. /* STM32 I2C 快速模式 */
  2. #define I2C_Speed                        400000
  3.  
  4. /* 这个地址只要与STM32外挂的I2C器件地址不一样即可 */
  5. #define I2C_OWN_ADDRESS7                 0x0A
  6. static void I2C_Mode_Config(void)
  7. {
  8.   I2C_InitTypeDef  I2C_InitStructure; 
  9.  
  10.   /* I2C 配置 */
  11.   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;	
  12.   I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;		                     /* 高电平数据稳定，低电平数据变化 SCL 时钟线的占空比 */
  13.   I2C_InitStructure.I2C_OwnAddress1 =I2C_OWN_ADDRESS7;
  14.   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;	
  15.   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;	
  16.   /* I2C的寻址模式 */
  17.   I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;	                            
  18.   /* 通信速率 */
  19.   I2C_Init(GTP_I2C, &I2C_InitStructure);	                                     /* I2C1 初始化 */
  20.   I2C_Cmd(GTP_I2C, ENABLE);  	                                                 /* 使能 I2C1 */
  21.  
  22.   I2C_AcknowledgeConfig(GTP_I2C, ENABLE);
  23.   
  24. }

 最后封装一下初始化所需要的函数：

  1. void I2C_Touch_Init(void)
  2. {
  3.         I2C_GPIO_Config();
  4.  
  5.         I2C_Mode_Config();
  6.  
  7.         I2C_ResetChip();
  8.  
  9.         I2C_GTP_IRQEnable();
  10. }

下面的函数都是移植了Linux（gt9xx.c）中的驱动函数：

在函数中有一个结构体数组，在IIC中有读写复合的方式进行通讯，上面的函数正表示了这一点，在Linux驱动中通过将写入与读取封装在一个结构体数组中，进行了这种复合方式。

  1. //寄存器地址的长度
  2. #define GTP_ADDR_LENGTH 2
  3.  
  4. /**
  5.   * @brief   从IIC设备中读取数据
  6.   * @param
  7.   *		@arg client_addr:设备地址
  8.   *		@arg  buf[0~1]: 读取数据寄存器的起始地址
  9.   *		@arg buf[2~len-1]: 存储读出来数据的缓冲buffer
  10.   *		@arg len:    GTP_ADDR_LENGTH + read bytes count（寄存器地址长度+读取的数据字节数）
  11.   * @retval  i2c_msgs传输结构体的个数，2为成功，其它为失败
  12.   */
  13. static int32_t GTP_I2C_Read(uint8_t client_addr, uint8_t *buf, int32_t len)
  14. {
  15.     struct i2c_msg msgs[2];
  16.     int32_t ret=-1;
  17.     int32_t retries = 0;
  18.  
  19.     GTP_DEBUG_FUNC();
  20.     /*一个读数据的过程可以分为两个传输过程:
  21.      * 1. IIC  写入 要读取的寄存器地址
  22.      * 2. IIC  读取  数据
  23.      * */
  24.  
  25.     msgs[0].flags = !I2C_M_RD;			//写入
  26.     msgs[0].addr  = client_addr;		//IIC设备地址
  27.     msgs[0].len   = GTP_ADDR_LENGTH;	//寄存器地址为2字节(即写入两字节的数据)
  28.     msgs[0].buf   = &buf[0];			//buf[0~1]存储的是要读取的寄存器地址
  29.     
  30.     msgs[1].flags = I2C_M_RD;				//读取
  31.     msgs[1].addr  = client_addr;			//IIC设备地址
  32.     msgs[1].len   = len - GTP_ADDR_LENGTH;	//要读取的数据长度
  33.     msgs[1].buf   = &buf[GTP_ADDR_LENGTH];	//buf[GTP_ADDR_LENGTH]之后的缓冲区存储读出的数据
  34.  
  35.     while(retries < 5)
  36.     {
  37.         ret = I2C_Transfer( msgs, 2);					//调用IIC数据传输过程函数，有2个传输过程
  38.         if(ret == 2)break;
  39.         retries++;
  40.     }
  41.     if((retries >= 5))
  42.     {
  43.         GTP_ERROR("I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((uint16_t)(buf[0] << 8)) | buf[1]), len-2, ret);
  44.     }
  45.     return ret;
  46. }
  47. //需要注意的是，其中buf的前两个字节表示寄存器地址，且len的长度为buf的整体长度

 复合读过程的步骤：

复合写过程的步骤：

 其中提到的通讯结构体：

  1. /* 表示读数据 */ 
  2. #define I2C_M_RD		0x0001	
  3.  /*
  4.  * 存储I2C通讯的信息
  5.  * @addr：  从设备的I2C设备地址	
  6.  * @flags: 控制标志
  7.  * @len：  读写数据的长度
  8.  * @buf：  存储读写数据的指针
  9.  **/
  10. struct i2c_msg {
  11. 	uint8_t addr;		/*从设备的I2C设备地址 */
  12. 	uint16_t flags;		/*控制标志*/
  13. 	uint16_t len;		/*读写数据的长度*/
  14. 	uint8_t *buf;		/*存储读写数据的指针	*/
  15. };

  • addr：从机的IIC设备地址，通讯时无论是读方向还是写方向，给这个成员赋值为写地址即可（0xBA）。

  • flags：存储了控制标志，用于指示i2c_msg结构体要求以什么方式来传输（读or写）。在原来的Linux驱动中有很多种控制方式，在这里被赋值为I2C_M_RD表示读。

  • len：数据长度。

  • buf：存储了指向读写数据缓冲区的指针。

在读取数据时，使用以下的函数，判断结构体数组中是读取的数据包还是要接收的数据包，这样就使读取与写入都可以封装在一个函数中，牛：I2C_Transfer的主要输入参数是i2c_msg结构体的指针以及要传输多少个这样的结构体，属于Linux内部的驱动层，对外提供接口。

 

  1. /**
  2.   * @brief   使用IIC进行数据传输
  3.   * @param
  4.   *		@arg i2c_msg:数据传输结构体
  5.   *		@arg num:数据传输结构体的个数
  6.   * @retval  正常完成的传输结构个数，若不正常，返回0xff
  7.   */
  8. static int I2C_Transfer( struct i2c_msg *msgs,int num)
  9. {
  10. 	int im = 0;
  11. 	int ret = 0;
  12.  
  13. 	GTP_DEBUG_FUNC();
  14. 	//将结构体一个个地传输出去
  15. 	for (im = 0; ret == 0 && im != num; im++)
  16. 	{
  17. 		if ((msgs[im].flags&I2C_M_RD))												//根据flag判断是读数据还是写数据
  18. 		{
  19. 			ret = I2C_ReadBytes(msgs[im].addr, msgs[im].buf, msgs[im].len);			//IIC读取数据
  20. 		} else
  21. 		{
  22. 			ret = I2C_WriteBytes(msgs[im].addr,  msgs[im].buf, msgs[im].len);	//IIC写入数据
  23. 		}
  24. 	}
  25.  
  26. 	if(ret)
  27. 		return ret;
  28.  
  29. 	return im;   							//正常完成的传输结构个数
  30. }

后面的读取数据与接收数据都使用软件IIC的方式进行：

  1. /**
  2.   * @brief   使用IIC读取数据
  3.   * @param   
  4.   * 	@arg ClientAddr:从设备地址
  5.   *		@arg pBuffer:存放由从机读取的数据的缓冲区指针
  6.   *		@arg NumByteToRead:读取的数据长度
  7.   * @retval  无
  8.   */
  9. uint32_t I2C_ReadBytes(uint8_t ClientAddr,uint8_t* pBuffer, uint16_t NumByteToRead)
  10. {
  11. 	
  12. 	/* 第1步：发起I2C总线启动信号 */
  13. 	i2c_Start();
  14. 	
  15. 	/* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  16. 	i2c_SendByte(ClientAddr | I2C_DIR_RD);	/* 此处是读指令 */
  17. 	
  18. 	/* 第3步：等待ACK */
  19. 	if (i2c_WaitAck() != 0)
  20. 	{
  21. 		goto cmd_fail;	/* 器件无应答 */
  22. 	}
  23.  
  24. 	while(NumByteToRead) 
  25.    {
  26.    if(NumByteToRead == 1)
  27.     {
  28. 			i2c_NAck();	/* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1) */
  29.       
  30.       		/* 发送I2C总线停止信号 */
  31.       		i2c_Stop();
  32.     }
  33.     
  34.    *pBuffer = i2c_ReadByte();
  35.     
  36.     /* 读指针自增 */
  37.     pBuffer++; 
  38.       
  39.     /*计数器自减 */
  40.     NumByteToRead--;
  41.     
  42.     i2c_Ack();	/* 中间字节读完后，CPU产生ACK信号(驱动SDA = 0) */  
  43.   }
  44.  
  45. 	/* 发送I2C总线停止信号 */
  46. 	i2c_Stop();
  47. 	return 0;	/* 执行成功 */
  48.  
  49. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  50. 	/* 发送I2C总线停止信号 */
  51. 	i2c_Stop();
  52. 	return 1;
  53. }
  54.  
  55.  
  56. /**
  57.   * @brief   使用IIC写入数据
  58.   * @param   
  59.   * 	@arg ClientAddr:从设备地址
  60.   *		@arg pBuffer:缓冲区指针
  61.   *     @arg NumByteToWrite:写的字节数
  62.   * @retval  无
  63.   */
  64. uint32_t I2C_WriteBytes(uint8_t ClientAddr,uint8_t* pBuffer,  uint8_t NumByteToWrite)
  65. {
  66. 	uint16_t m;	
  67.  
  68.   /*　第0步：发停止信号，启动内部写操作　*/
  69.   i2c_Stop();
  70.   
  71.   /* 通过检查器件应答的方式，判断内部写操作是否完成, 一般小于 10ms 			
  72.     CLK频率为200KHz时，查询次数为30次左右
  73.   */
  74.   for (m = 0; m < 1000; m++)
  75.   {				
  76.     /* 第1步：发起I2C总线启动信号 */
  77.     i2c_Start();
  78.     
  79.     /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
  80.     i2c_SendByte(ClientAddr | I2C_DIR_WR);	/* 此处是写指令 */
  81.     
  82.     /* 第3步：发送一个时钟，判断器件是否正确应答 */
  83.     if (i2c_WaitAck() == 0)
  84.     {
  85.       break;
  86.     }
  87.   }
  88.   if (m  == 1000)
  89.   {
  90.     goto cmd_fail;	/* EEPROM器件写超时 */
  91.   }	
  92. 	
  93.   while(NumByteToWrite--)
  94.   {
  95.   /* 第4步：开始写入数据 */
  96.   i2c_SendByte(*pBuffer);
  97.  
  98.   /* 第5步：检查ACK */
  99.   if (i2c_WaitAck() != 0)
  100.   {
  101.     goto cmd_fail;	/* 器件无应答 */
  102.   }
  103.   
  104.       pBuffer++;	/* 地址增1 */		
  105.   }
  106. 	
  107. 	/* 命令执行成功，发送I2C总线停止信号 */
  108. 	i2c_Stop();
  109. 	return 0;
  110.  
  111. cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
  112. 	/* 发送I2C总线停止信号 */
  113. 	i2c_Stop();
  114. 	return 1;
  115. }

上面的两个读写函数都是很纯粹的IIC读写过程，没有包含寄存器的地址，这两个函数都通过调用数据包进行传输设备地址、缓冲区指针以及数据量。

接下来是读取触控芯片的产品ID及其版本号：

由前面介绍的，寄存器是存放于0x8140这个寄存器中。

  1. //设定使用的电容屏的IIC设备地址
  2. #define GTP_ADDRESS 	0XBA
  3. //芯片版本号地址
  4. #define GTP_REG_VERSION	0X8140
  5.  
  6. int32_t GTP_Read_Version(void)
  7. {
  8.     int32_t ret = -1;
  9.     uint8_t buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};    //寄存器地址
  10.  
  11.     GTP_DEBUG_FUNC();
  12.  
  13.     ret = GTP_I2C_Read(GTP_ADDRESS, buf, sizeof(buf));
  14.     if (ret < 0)
  15.     {
  16.         GTP_ERROR("GTP read version failed");
  17.         return ret;
  18.     }
  19.  
  20.     if (buf[4] == '1')
  21.     {				
  22. 				//GT911芯片
  23. 				if(buf[2] == '9' && buf[3] == '1' && buf[4] == '1')
  24.         {
  25.           GTP_INFO("IC1 Version: %c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[7], buf[6]);
  26.  
  27. 					touchIC = GT911;
  28.           /* 设置当前的液晶屏类型 */
  29.           cur_lcd = INCH_7;
  30.         }
  31.         //GT9157芯片
  32.         else
  33.            GTP_INFO("Unknown IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  34. 		}
  35. 		else if (buf[4] == '5')
  36. 		{
  37. 			if( buf[2] == '9' && buf[3] == '1' && buf[4] == '5' && buf[5] == '7')
  38.         {
  39.           GTP_INFO("IC2 Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  40.  
  41. 					touchIC = GT9157;
  42.           /* 设置当前的液晶屏类型 */
  43.           cur_lcd = INCH_5;
  44.         }
  45.         else
  46.            GTP_INFO("Unknown IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  47.  
  48.     }    
  49.     else if (buf[4] == '8')
  50.     {	
  51. 				//GT5688芯片
  52. 				if(buf[2] == '5' && buf[3] == '6' && buf[4] == '8' && buf[5] == '8')
  53.         {
  54.           GTP_INFO("IC3 Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  55.  
  56. 					touchIC = GT5688;
  57.           /* 设置当前的液晶屏类型 */
  58.           cur_lcd = INCH_4_3;
  59.         }
  60.         else
  61.            GTP_INFO("Unknown IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  62.  
  63.     }
  64. 		else if(buf[4] == '7')
  65.     {
  66. 			  //GT917S芯片
  67.          GTP_INFO("IC2 Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  68. 				
  69. 				if(buf[2] == '9' && buf[3] == '1' && buf[4] == '7' && buf[5] == 'S')
  70. 				{	
  71. 					touchIC = GT917S; 
  72. 					/* 设置当前的液晶屏类型 */
  73.           cur_lcd = INCH_5;	
  74. 				}					
  75.     }
  76.     else 
  77.        GTP_INFO("Unknown IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
  78.  
  79.     return ret;
  80. }

 上面那个函数定义了一个8字节的buf数组，并且向他的第0个和第1个元素写入产品ID寄存器的地址，然后调用复合函数读取数据，之后就可以读取寄存器的信息，利用下面这个宏：

#define GTP_INFO(fmt,arg...)           printf("<<-GTP-INFO->> "fmt"\n",##arg)

之后向触控芯片写入参数：

我们识别出是哪一种产品id后，我们就可以往显示屏里面写入配置参数到寄存器中：

 

 在函数中定义了一个枚举，存放了所有的产品型号：

 之后在下面这个函数进行了初始化，也调用了I2C_Touch_Init初始化了STM32的IIC外设，设定触控芯片的IIC设备地址，然后调用了上面的获取触控芯片的版本号。之后将配置参数表写入到触控芯片的配置寄存器中，在传输中包含由checksum寄存器的值，需要利用其来校验数据。

  1. int32_t GTP_Init_Panel(void)
  2. {
  3.     int32_t ret = -1;
  4.  
  5.     int32_t i = 0;
  6.     uint16_t check_sum = 0;
  7.     int32_t retry = 0;
  8.  
  9.     const uint8_t* cfg_info;
  10.     uint8_t cfg_info_len  ;
  11. 	uint8_t* config;
  12.  
  13.     uint8_t cfg_num =0 ;		//需要配置的寄存器个数
  14. 	//查错函数
  15.     GTP_DEBUG_FUNC();
  16. 	
  17.     I2C_Touch_Init();
  18.  
  19.     ret = GTP_I2C_Test();
  20.     if (ret < 0)
  21.     {
  22.         GTP_ERROR("I2C communication ERROR!");
  23. 				return ret;
  24.     } 
  25. 		
  26. 		//获取触摸IC的型号
  27.     GTP_Read_Version(); 
  28.     
  29. #if UPDATE_CONFIG
  30.  
  31. 		config = (uint8_t *)malloc (GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH);
  32.  
  33. 		config[0] = GTP_REG_CONFIG_DATA >> 8;
  34. 		config[1] =  GTP_REG_CONFIG_DATA & 0xff;
  35. 		
  36. 		//根据IC的型号指向不同的配置
  37. 		if(touchIC == GT9157)
  38. 		{
  39. 			cfg_info =  CTP_CFG_GT9157; //指向寄存器配置
  40. 			cfg_info_len = CFG_GROUP_LEN(CTP_CFG_GT9157);//计算配置表的大小
  41. 		}
  42. 		else if(touchIC == GT911)
  43. 		{
  44. 			cfg_info =  CTP_CFG_GT911;//指向寄存器配置
  45. 			cfg_info_len = CFG_GROUP_LEN(CTP_CFG_GT911) ;//计算配置表的大小
  46. 		}
  47. 		else if(touchIC == GT5688)			
  48. 		{
  49. 			cfg_info =  CTP_CFG_GT5688; //指向寄存器配置
  50. 			cfg_info_len = CFG_GROUP_LEN(CTP_CFG_GT5688);//计算配置表的大小
  51. 		}
  52. 		else if(touchIC == GT917S)
  53. 		{
  54. 			cfg_info =  CTP_CFG_GT917S; //指向寄存器配置
  55. 			cfg_info_len = CFG_GROUP_LEN(CTP_CFG_GT917S);//计算配置表的大小
  56. 		}
  57. 		
  58.     memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH);
  59.     memcpy(&config[GTP_ADDR_LENGTH], cfg_info, cfg_info_len);
  60. 		
  61. 		cfg_num = cfg_info_len;
  62. 		
  63. 		GTP_DEBUG("cfg_info_len = %d ",cfg_info_len);
  64. 		GTP_DEBUG("cfg_num = %d ",cfg_num);
  65. 		GTP_DEBUG_ARRAY(config,6);
  66. 		
  67. 		/*根据LCD的扫描方向设置分辨率*/
  68. 		config[GTP_ADDR_LENGTH+1] = LCD_PIXEL_WIDTH & 0xFF;
  69. 		config[GTP_ADDR_LENGTH+2] = LCD_PIXEL_WIDTH >> 8;
  70. 		config[GTP_ADDR_LENGTH+3] = LCD_PIXEL_HEIGHT & 0xFF;
  71. 		config[GTP_ADDR_LENGTH+4] = LCD_PIXEL_HEIGHT >> 8;
  72. 		
  73. 		/*根据模式设置X2Y交换*/
  74.  
  75.     //不交换
  76. //		config[GTP_ADDR_LENGTH+6] &= ~(X2Y_LOC);
  77.  
  78.     //交换
  79. //    config[GTP_ADDR_LENGTH+6] |= (X2Y_LOC);
  80.  
  81.     //计算要写入checksum寄存器的值
  82.     check_sum = 0;
  83.  
  84.     /* 计算check sum校验值 */
  85.     if(touchIC == GT911 || touchIC == GT9157)
  86.     {
  87.         for (i = GTP_ADDR_LENGTH; i < cfg_num+GTP_ADDR_LENGTH; i++)
  88.         {
  89.             check_sum += (config[i] & 0xFF);
  90.         }
  91.         config[ cfg_num+GTP_ADDR_LENGTH] = (~(check_sum & 0xFF)) + 1; 	//checksum
  92.         config[ cfg_num+GTP_ADDR_LENGTH+1] =  1; 						//refresh 配置更新标志
  93.     }
  94.     else if(touchIC == GT5688 || touchIC == GT917S) 
  95.     {
  96.       for (i = GTP_ADDR_LENGTH; i < (cfg_num+GTP_ADDR_LENGTH -3); i += 2) 
  97.       {
  98.         check_sum += (config[i] << 8) + config[i + 1];
  99.       }
  100.       
  101.       check_sum = 0 - check_sum;
  102.       GTP_DEBUG("Config checksum: 0x%04X", check_sum);
  103.       //更新checksum
  104.       config[(cfg_num+GTP_ADDR_LENGTH -3)] = (check_sum >> 8) & 0xFF;
  105.       config[(cfg_num+GTP_ADDR_LENGTH -2)] = check_sum & 0xFF;
  106.       config[(cfg_num+GTP_ADDR_LENGTH -1)] = 0x01;
  107.     }
  108.  
  109.     //写入配置信息
  110.     for (retry = 0; retry < 5; retry++)
  111.     {
  112.         ret = GTP_I2C_Write(GTP_ADDRESS, config , cfg_num + GTP_ADDR_LENGTH+2);
  113.         if (ret > 0)
  114.         {
  115.             break;
  116.         }
  117.     }
  118.     Delay(0xfffff);				//延迟等待芯片更新
  119. 		
  120.  
  121. 		
  122. #if 1	//读出写入的数据，检查是否正常写入
  123.     //检验读出的数据与写入的是否相同
  124. 	{
  125.     	    uint16_t i;
  126.     	    uint8_t buf[300];
  127.     	     buf[0] = config[0];
  128.     	     buf[1] =config[1];    //寄存器地址
  129.  
  130.     	    GTP_DEBUG_FUNC();
  131.  
  132.     	    ret = GTP_I2C_Read(GTP_ADDRESS, buf, sizeof(buf));
  133. 			   
  134. 			GTP_DEBUG("read ");
  135.  
  136. 			GTP_DEBUG_ARRAY(buf,cfg_num);
  137. 		
  138. 			GTP_DEBUG("write ");
  139.  
  140. 			GTP_DEBUG_ARRAY(config,cfg_num);
  141.  
  142. 					//不对比版本号
  143.     	    for(i=3;i<cfg_num+GTP_ADDR_LENGTH-3;i++)
  144.     	    {
  145.  
  146.     	    	if(config[i] != buf[i])
  147.     	    	{
  148.     	    		GTP_ERROR("Config fail ! i = %d ",i);
  149. 							free(config);
  150.     	    		return -1;
  151.     	    	}
  152.     	    }
  153.     	    if(i==cfg_num+GTP_ADDR_LENGTH-3)
  154. 	    		GTP_DEBUG("Config success ! i = %d ",i);
  155. 	}
  156. #endif
  157. 	free(config);
  158.  
  159. #endif
  160. 	 /* emXGUI示例中不使能中断 */
  161. 		GTP_IRQ_Enable();
  162. 	
  163.     	GTP_Get_Info();
  164. 		
  165. 		
  166.  
  167.     return 0;
  168. }
  169.  
  170. #define GTP_INFO(fmt,arg...)           printf("<<-GTP-INFO->> "fmt"\n",##arg)
  171. #define GTP_ERROR(fmt,arg...)          printf("<<-GTP-ERROR->> "fmt"\n",##arg)
  172. #define GTP_DEBUG(fmt,arg...)          do{\
  173.                                          if(GTP_DEBUG_ON)\
  174.                                          printf("<<-GTP-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  175. 																					}while(0)
  176.  
  177. #define GTP_DEBUG_ARRAY(array, num)    do{\
  178.                                          int32_t i;\
  179.                                          uint8_t* a = array;\
  180.                                          if(GTP_DEBUG_ARRAY_ON)\
  181.                                          {\
  182.                                             printf("<<-GTP-DEBUG-ARRAY->>\n");\
  183.                                             for (i = 0; i < (num); i++)\
  184.                                             {\
  185.                                                 printf("%02x   ", (a)[i]);\
  186.                                                 if ((i + 1 ) %10 == 0)\
  187.                                                 {\
  188.                                                     printf("\n");\
  189.                                                 }\
  190.                                             }\
  191.                                             printf("\n");\
  192.                                         }\
  193.                                        }while(0)
  194.  
  195. #define GTP_DEBUG_FUNC()               do{\
  196.                                          if(GTP_DEBUG_FUNC_ON)\
  197.                                          printf("<<-GTP-FUNC->> Func:%s@Line:%d\n",__func__,__LINE__);\
  198.                                        }while(0)
  199.  
  200. 																			 
  201. 																			 
  202. #define GTP_SWAP(x, y)                 do{\
  203.                                          typeof(x) z = x;\
  204.                                          x = y;\
  205.                                          y = z;\
  206.                                        }while (0)

INT中断服务函数

  1. void SysTick_Handler(void)
  2. {
  3.  
  4. 	static uint8_t timecount=0;
  5. 	if(timecount>=10)
  6. 	{
  7. 		timecount=0;
  8.         //此函数的作用是读取触摸坐标
  9. 		GTP_TouchProcess();
  10. 	}
  11. 	TimingDelay_Decrement();
  12. 	timecount++;
  13. }
  14.  
  15. void GTP_TouchProcess(void)
  16. {
  17.   GTP_DEBUG_FUNC();
  18.   Goodix_TS_Work_Func();
  19.  
  20. }

核心在于下面这个函数：

  1. //状态寄存器地址
  2. #define GTP_READ_COOR_ADDR 0X814E
  3.  
  4. /**
  5.   * @brief   触屏处理函数，轮询或者在触摸中断调用
  6.   * @param 无
  7.   * @retval 无
  8.   */
  9. static void Goodix_TS_Work_Func(void)
  10. {
  11.     uint8_t  end_cmd[3] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0};
  12.     uint8_t  point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1]={GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF};
  13.     uint8_t  touch_num = 0;
  14.     uint8_t  finger = 0;
  15.     static uint16_t pre_touch = 0;
  16.     static uint8_t pre_id[GTP_MAX_TOUCH] = {0};
  17.  
  18.     uint8_t client_addr=GTP_ADDRESS;
  19.     uint8_t* coor_data = NULL;
  20.     int32_t input_x = 0;
  21.     int32_t input_y = 0;
  22.     int32_t input_w = 0;
  23.     uint8_t id = 0;
  24.  
  25.     int32_t i  = 0;
  26.     int32_t ret = -1;
  27.  
  28.     GTP_DEBUG_FUNC();
  29.  
  30.     ret = GTP_I2C_Read(client_addr, point_data, 12);//10字节寄存器加2字节地址
  31.     if (ret < 0)
  32.     {
  33.         GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
  34.  
  35.         return;
  36.     }
  37.     
  38.     finger = point_data[GTP_ADDR_LENGTH];//状态寄存器数据
  39.  
  40.     if (finger == 0x00)		//没有数据，退出
  41.     {
  42.         return;
  43.     }
  44.  
  45.     if((finger & 0x80) == 0)//判断buffer status位
  46.     {
  47.         goto exit_work_func;//坐标未就绪，数据无效
  48.     }
  49.  
  50.     touch_num = finger & 0x0f;//坐标点数
  51.     if (touch_num > GTP_MAX_TOUCH)
  52.     {
  53.         goto exit_work_func;//大于最大支持点数，错误退出
  54.     }
  55.  
  56.     if (touch_num > 1)//不止一个点
  57.     {
  58.         uint8_t buf[8 * GTP_MAX_TOUCH] = {(GTP_READ_COOR_ADDR + 10) >> 8, (GTP_READ_COOR_ADDR + 10) & 0xff};
  59.  
  60.         ret = GTP_I2C_Read(client_addr, buf, 2 + 8 * (touch_num - 1));
  61.         memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1));			//复制其余点数的数据到point_data
  62.     }
  63.  
  64.     
  65.     
  66.     if (pre_touch>touch_num)				//pre_touch>touch_num,表示有的点释放了
  67.     {
  68.         for (i = 0; i < pre_touch; i++)		//一个点一个点处理
  69.          {
  70.             uint8_t j;
  71.            for(j=0; j<touch_num; j++)
  72.            {
  73.                coor_data = &point_data[j * 8 + 3];
  74.                id = coor_data[0] & 0x0F;									//track id
  75.               if(pre_id[i] == id)
  76.                 break;
  77.  
  78.               if(j >= touch_num-1)			//遍历当前所有id都找不到pre_id[i]，表示已释放
  79.               {
  80.                  GTP_Touch_Up( pre_id[i]);
  81.               }
  82.            }
  83.        }
  84.     }
  85.  
  86.  
  87.     if (touch_num)
  88.     {
  89.         for (i = 0; i < touch_num; i++)		//一个点一个点处理
  90.         {
  91.             coor_data = &point_data[i * 8 + 3];
  92.  
  93.             id = coor_data[0] & 0x0F;									//track id
  94.             pre_id[i] = id;
  95.  
  96.             input_x  = coor_data[1] | (coor_data[2] << 8);	//x坐标
  97.             input_y  = coor_data[3] | (coor_data[4] << 8);	//y坐标
  98.             input_w  = coor_data[5] | (coor_data[6] << 8);	//size
  99.         
  100.             {
  101.                 GTP_Touch_Down( id, input_x, input_y, input_w);//数据处理
  102.             }
  103.         }
  104.     }
  105.     else if (pre_touch)		//touch_ num=0 且pre_touch！=0
  106.     {
  107.       for(i=0;i<pre_touch;i++)
  108.       {
  109.           GTP_Touch_Up(pre_id[i]);
  110.       }
  111.     }
  112.  
  113.  
  114.     pre_touch = touch_num;
  115.  
  116.  
  117. exit_work_func:
  118.     {
  119.         ret = GTP_I2C_Write(client_addr, end_cmd, 3);
  120.         if (ret < 0)
  121.         {
  122.             GTP_INFO("I2C write end_cmd error!");
  123.         }
  124.     }
  125.  
  126. }

这个函数内容在于，首先读取了状态寄存器，获取当前有多少个触电，然后根据触点数去读取各个点的数据，其中还有包含pre_touch的处理，保存了上一点的触点数据，利用这些数据和触电的track id号，可以确认同一条笔迹。读取后，对状态寄存器的buffer status位写0，结束读取。在这个函数中提供了两个坐标获取接口，只要在这两个接口中修改即可简单地得到了坐标信息。

触点释放和触点按下的坐标接口：

  1. /**
  2.   * @brief   用于处理或报告触屏检测到按下
  3.   * @param
  4.   *    @arg     id: 触摸顺序trackID
  5.   *    @arg     x:  触摸的 x 坐标
  6.   *    @arg     y:  触摸的 y 坐标
  7.   *    @arg     w:  触摸的 大小
  8.   * @retval 无
  9.   */
  10. /*用于记录连续触摸时(长按)的上一次触摸位置，负数值表示上一次无触摸按下*/
  11. static int16_t pre_x[GTP_MAX_TOUCH] ={-1,-1,-1,-1,-1};
  12. static int16_t pre_y[GTP_MAX_TOUCH] ={-1,-1,-1,-1,-1};
  13.  
  14. static void GTP_Touch_Down(int32_t id,int32_t x,int32_t y,int32_t w)
  15. {
  16.   
  17. 	GTP_DEBUG_FUNC();
  18.  
  19. 	/*取x、y初始值大于屏幕像素值*/
  20.     GTP_DEBUG("ID:%d, X:%d, Y:%d, W:%d", id, x, y, w);
  21.  
  22. 	
  23.     /* 处理触摸按钮，用于触摸画板 */
  24.     Touch_Button_Down(x,y); 
  25. 	
  26.  
  27.     /*处理描绘轨迹，用于触摸画板 */
  28.     Draw_Trail(pre_x[id],pre_y[id],x,y,&brush);
  29. 	
  30. 		/************************************/
  31. 		/*在此处添加自己的触摸点按下时处理过程即可*/
  32. 		/* (x,y) 即为最新的触摸点 *************/
  33. 		/************************************/
  34. 	
  35. 		/*prex,prey数组存储上一次触摸的位置，id为轨迹编号(多点触控时有多轨迹)*/
  36.     pre_x[id] = x; pre_y[id] =y;
  37. 	
  38. }
  39.  
  40.  
  41. /**
  42.   * @brief   用于处理或报告触屏释放
  43.   * @param 释放点的id号
  44.   * @retval 无
  45.   */
  46. static void GTP_Touch_Up( int32_t id)
  47. {
  48. 	
  49.  
  50.     /*处理触摸释放,用于触摸画板*/
  51.     Touch_Button_Up(pre_x[id],pre_y[id]);
  52.  
  53. 		/*****************************************/
  54. 		/*在此处添加自己的触摸点释放时的处理过程即可*/
  55. 		/* pre_x[id],pre_y[id] 即为最新的释放点 ****/
  56. 		/*******************************************/	
  57. 		/***id为轨迹编号(多点触控时有多轨迹)********/
  58. 	
  59. 	
  60.     /*触笔释放，把pre xy 重置为负*/
  61. 	  pre_x[id] = -1;
  62. 	  pre_y[id] = -1;		
  63.   
  64.     GTP_DEBUG("Touch id[%2d] release!", id);
  65.  
  66. }

这两个坐标接口函数都还是在服务函数里面调用的，在实际应用中可以先把这些坐标信息存储起来，等待到系统空闲的时候再处理，就可以减轻中断服务程序的负担。

最后的主函数：

 

  1. int main(void)
  2. {
  3. 	/* LED 端口初始化 */
  4. 	LED_GPIO_Config();	
  5. 	
  6.   Debug_USART_Config();    
  7.   printf("\r\n野火STM3F429 触摸画板测试例程\r\n");
  8.  
  9.  
  10.   /* 初始化触摸屏 */
  11.   GTP_Init_Panel(); 
  12.   SysTick_Init();
  13.  /*初始化液晶屏*/
  14.   LCD_Init();
  15. 	
  16.  
  17.   LCD_LayerInit();
  18.   LTDC_Cmd(ENABLE);
  19. 	
  20.   /*把背景层刷黑色*/
  21.   LCD_SetLayer(LCD_BACKGROUND_LAYER);  
  22.   LCD_Clear(LCD_COLOR_BLACK);
  23. 	
  24.   /*初始化后默认使用前景层*/
  25.   LCD_SetLayer(LCD_FOREGROUND_LAYER); 
  26.   /*默认设置不透明	，该函数参数为不透明度，范围 0-0xff ，0为全透明，0xff为不透明*/
  27.   LCD_SetTransparency(0xFF);
  28.   LCD_Clear(LCD_COLOR_BLACK);
  29.  
  30.  
  31.   Delay(0xfff);
  32.    
  33.  
  34.   while(1);
  35.    
  36.  
  37. }

最后关于应用层，放在另外一章吧。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/594011
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号