stm32驱动 ra8875电容屏

只看该作者 · 2018-10-30 20:24

对GT91xx芯片进行复位
void I2C_ResetChip(void)
{
GPIO_InitTypeDef GPIO_InitStructure;

/*!< Configure 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);

/*初始化GT9157,rst为高电平，int为低电平，则gt9157的设备地址被配置为0xBA*/

/*复位为低电平，为初始化做准备*/
GPIO_ResetBits (GTP_INT_GPIO_PORT,GTP_INT_GPIO_PIN);
GPIO_ResetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
Delay(0x0FFFFF);

/*拉高一段时间，进行初始化*/
GPIO_SetBits (GTP_RST_GPIO_PORT,GTP_RST_GPIO_PIN);
Delay(0x0FFFFF);
}

只看该作者 · 2018-10-30 20:25

I2C 外设(GT91xx)初始化

void I2C_Touch_Init(void)
{
  I2C_GPIO_Config();

  /*必须要复位芯片以设置IIC地址*/
  I2C_ResetChip();
}

只看该作者 · 2018-10-30 20:26

gt9xx电容屏驱动函数

使用IIC进行数据传输
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; //正常完成的传输结构个数
}

只看该作者 · 2018-10-30 20:26

从IIC设备中读取数据
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|0x01; //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;
}

只看该作者 · 2018-10-30 20:27

向IIC设备写入数据

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;
}

只看该作者 · 2018-10-30 20:28

使用IIC读取再次数据，检验是否正常

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;
}

只看该作者 · 2018-10-30 20:28

用于处理或报告触屏检测到按下

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

GTP_DEBUG("X:%d, Y:%d, W:%d", x, y, w);

pre_x = x; pre_y=y;
}

只看该作者 · 2018-10-30 20:28

用于处理或报告触屏释放

static void GTP_Touch_Up(void)
{

/*触笔释放，把pre xy 重置为负*/
pre_x = -1;
pre_y = -1;

GTP_DEBUG("Touch release!");
}

只看该作者 · 2018-10-30 20:29

触屏处理函数，轮询或者在触摸中断调用

static void Goodix_TS_Work_Func(void)
{
static uint8_t IsTouch=0;
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;

uint8_t client_addr=GTP_ADDRESS;
int32_t input_x = 0;
int32_t input_y = 0;
int32_t input_w = 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];//状态寄存器数据

GTP_DEBUG("I2C finger:%X",finger);

if(finger == 0x00) //没有数据，退出
{
if(IsTouch)
{
GTP_Touch_Up();
IsTouch=0;
}
      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;//大于最大支持点数，错误退出
}
IsTouch=1;
input_x  = point_data[4] | (point_data[5] << 8); //x坐标
input_y  = point_data[6] | (point_data[7] << 8); //y坐标
input_w  = point_data[8] | (point_data[9] << 8); //size

GTP_Touch_Down(input_x, input_y, input_w);//数据处理

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

}

只看该作者 · 2018-10-30 20:29

给触屏芯片重新复位

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

}

只看该作者 · 2018-10-30 20:30

唤醒触摸屏

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;
}

只看该作者 · 2018-10-30 20:30

int32_t GTP_Init_Panel(void)
{
int32_t ret = -1;

int32_t i = 0;
uint8_t check_sum = 0;
int32_t retry = 0;

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

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

GTP_DEBUG_FUNC();

I2C_Touch_Init();

ret = GTP_I2C_Test();
if (ret < 0)
{
      GTP_ERROR("I2C communication ERROR!");
}

GTP_Read_Version();

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;
      }
}
Delay(0xfffff); //延迟等待芯片更新

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

      GTP_DEBUG_FUNC();

      ret = GTP_I2C_Read(GTP_ADDRESS, buf, sizeof(buf));

      //版本号写入0x00后，会进行复位，复位为0x41
      config[GTP_ADDR_LENGTH] = 0x41;

      for(i=0;i<cfg_num+GTP_ADDR_LENGTH;i++)
      {

        if(config[i] != buf[i])
        {
        GTP_DEBUG("Config fail ! i = %d ",i);
        break;
        }
      }
      if(i==cfg_num+GTP_ADDR_LENGTH)
        GTP_DEBUG("Config success ! i = %d ",i);
}
#endif
GTP_Get_Info();
return 0;
}

只看该作者 · 2018-10-30 20:31

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[5] == 0x00)
{
      GTP_INFO("IC Version: %c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[7], buf[6]);
}
else
{
      GTP_INFO("IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
}
return ret;
}

只看该作者 · 2018-10-30 20:31

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;
}

只看该作者 · 2018-10-30 20:32

// 打点函数
void GT9xx_GetOnePiont(void)
{
GTP_DEBUG_FUNC();
Goodix_TS_Work_Func();
if((pre_x==-1) || (pre_y==-1))
{
State.x = -1;
State.y = -1;
State.Pressed = 0;
GUI_PID_StoreState(&State);
return;
}
State.Pressed = 1;
State.x = pre_x;
State.y =pre_y;
GUI_PID_StoreState(&State);
}