/************************************************************************

  * Copyright(c) 2023 Levetop Semiconductor Co.,Led. All rights reserved.

  * @file     rtp.c

  * @author   UartTFT Application Team

  * @version  V1.0.0

  * @date     2023-02-24

  * @brief     

 *************************************************************************/

#include "rtp.h"

#include "tp_drv.h"

#include "i2c_drv.h"

#include "uart_drv.h"

#include "iomacros.h"

uint8_t Rtp_Cor = 0;

void LT_TpDelay(void)

{

	uint8_t t = 1;

	while (t--)

	{

		__NOP();

		__NOP();

		__NOP();

		__NOP();

		__NOP();

		__NOP();

	}

}

#define CMD_RDX 0XD0

#define CMD_RDY 0X90

// SPI write data

void TP_Write_Byte(uint8_t num)

{

	uint8_t count = 0;

	for (count = 0; count < 8; count++)

	{

		if (num & 0x80)

			TDIN_SET;

		else

			TDIN_RESET;

		num <<= 1;

		TCLK_RESET;

		DelayUS(8);

		TCLK_SET;

		DelayUS(8);

	}

}

// SPI read data

// Read adc value from touch screen IC

// CMD:instruct

// Return value: read data

int16_t TP_Read_AD(CMD)

{

	uint8_t count = 0;

	uint16_t Num = 0;

	TCLK_RESET; // Lower the clock first

	TDIN_RESET; // Pull down the data cable

	TCS_RESET; // Select touch screen IC

	TP_Write_Byte(CMD);

	DelayUS(8); // The maximum conversion time of ADS7846 is 6us

	TCLK_RESET;

	DelayUS(8);

	TCLK_SET;

	DelayUS(8);

	TCLK_RESET;

	DelayUS(8);

	for (count = 0; count < 16; count++) // Read 16-bit data, only the upper 12 bits are valid

	{

		Num <<= 1;

		TCLK_RESET; // Falling edge effective

		DelayUS(8);

		TCLK_SET;

		DelayUS(8);

		if (GET_SDO_Bit)

			Num++;

		// printf("eport=%d\r\n",EPORT_ReadGpioData(EPORT_PIN3));

	}

	Num >>= 4;

	// Only the upper 12 bits are valid.

	TCS_SET; // Release the selection

	return Num;

}

//Read a coordinate value (x or y)

//Read READ continuously_ TIMES secondary data is arranged in ascending order,

//Then remove the lowest and highest LOST_ Number of VALs, take the average value

//Xy: Instruction (CMD_RDX/CMD_RDY)

//Return value: read data

#define READ_TIMES 8 // Reads

#define LOST_VAL 2	 // Discard value

uint16_t TP_Read_XOY(uint8_t xy)

{

	uint16_t i, j;

	uint16_t buf[READ_TIMES];

	uint16_t sum = 0;

	uint16_t temp;

	for (i = 0; i < READ_TIMES; i++)

		buf[i] = TP_Read_AD(xy);

	for (i = 0; i < READ_TIMES - 1; i++) // sort

	{

		for (j = i + 1; j < READ_TIMES; j++)

		{

			if (buf[i] > buf[j]) // Ascending

			{

				temp = buf[i];

				buf[i] = buf[j];

				buf[j] = temp;

			}

		}

	}

	sum = 0;

	for (i = LOST_VAL; i < READ_TIMES - LOST_VAL; i++)

		sum += buf[i];

	temp = sum / (READ_TIMES - 2 * LOST_VAL);

	return temp;

}

/********************************************************************************

* Function Name	: TP_Read_XY

* Description  	: Read the touch screen IC for two consecutive times, and the deviation between the two times cannot exceed.

* Input        	: - x,y: Read coordinate value

* Output       	: None

* Return       	: 0:error  1:ok

*********************************************************************************/

uint8_t TP_Read_XY(uint16_t *x, uint16_t *y)

{

	*x = TP_Read_XOY(CMD_RDX);

	*y = TP_Read_XOY(CMD_RDY);

	if (*x > 4095 || *y > 4095)

		return 0; // Reading failed

	//	printf("%d %d\r\n",*x,*y);

	return 1;

}

/********************************************************************************

* Function Name	: TP_Read_XY2

* Description  	: Read the touch screen IC for two consecutive times, and the deviation between the two times cannot exceed.

* Input        	: - x,y: Read coordinate value

* Output       	: None

* Return       	: 0:error  1:ok

*********************************************************************************/

#define ERR_RANGE 50 // Error range

uint8_t TP_Read_XY2(uint16_t *x, uint16_t *y)

{

	uint16_t x1, y1;

	uint16_t x2, y2;

	uint8_t flag;

	flag = TP_Read_XY(&x1, &y1);

	if (flag == 0)

		return (0);

	flag = TP_Read_XY(&x2, &y2);

	if (flag == 0)

		return (0);

	if (((x2 <= x1 && x1 < x2 + ERR_RANGE) || (x1 <= x2 && x2 < x1 + ERR_RANGE)) // 前后两次采样在+-50内

		&& ((y2 <= y1 && y1 < y2 + ERR_RANGE) || (y1 <= y2 && y2 < y1 + ERR_RANGE)))

	{

		*x = (x1 + x2) / 2;

		*y = (y1 + y2) / 2;

		return 1;

	}

	else

	{

		return 0;

	}

}

// Display correction point

void LT_TpDrawTouchPoint(uint16_t x, uint16_t y, uint32_t color)

{

	LT768_DrawLine(x - 12, y, x + 13, y, color); // Horizontal line

	LT768_DrawLine(x, y - 12, x, y + 13, color); // Vertical line

	LT768_DrawCircle(x, y, 6, color);			 // Draw center circle

}

/********************************************************************************

* Function Name	: TP_Read_XY2

* Description  	: touch scan.

* Input        	: None

* Output       	: None

* Return       	: 0:have touch event  1:no touch event

*********************************************************************************/

uint8_t LT_TpScan(void)

{

	if ((EPORT_ReadGpioData(EPORT_PIN4) == 0))

	{

		if (TP_Read_XY2(&gTpInfo.px, &gTpInfo.py))

		{

			Backlight_count = 0;

			//Backlight_touch = 1;

			if ((Backlight_flag == 0 || Backlight_touch == 2 ) && var[2 * 0x700e + 1] == 1 )

			{

				if (buzzer && Backlight_flag == 0)

					touch_buzzer();

				Set_Timer1_Compare_Buffer(gDutyBuf[var[0x7001 * 2 + 1]]);

				if (var[0x700f * 2 + 1] == 0)

					Start_PWM1();

				Backlight_touch = 2;

				gTpInfo.sta = 0;

				First_press = 0;

				Backlight_flag = 1;

			}

			else

			{

				gTpInfo.x[0] = gTpInfo.xfac * gTpInfo.px + gTpInfo.xoff;

				gTpInfo.y[0] = gTpInfo.yfac * gTpInfo.py + gTpInfo.yoff;

				if (gTpInfo.x[0] > LCD_XSIZE_TFT)

					gTpInfo.x[0] = LCD_XSIZE_TFT;

				if (gTpInfo.y[0] > LCD_YSIZE_TFT)

					gTpInfo.y[0] = LCD_YSIZE_TFT;

				if(scr_flag == 3)

				{

					if(scr_x != 0 || scr_y != 0)

						//LT768_DrawCircle_Fill(gTpInfo.x[0],gTpInfo.y[0],3,Red);

						LT768_DrawQuadrilateral_Fill(scr_x, scr_y + 3, scr_x + 3, scr_y, gTpInfo.x[0] + 3, gTpInfo.y[0], gTpInfo.x[0], gTpInfo.y[0] + 3, Red);

					scr_x = gTpInfo.x[0];

					scr_y = gTpInfo.y[0];

				}

				if (First_press == 0)

				{

					First_press = 1;

					First_pressX = gTpInfo.x[0];

					First_pressY = gTpInfo.y[0];

				}

				/* debug

					printf("X=%d Y=%d \r\n",gTpInfo.x[0],gTpInfo.y[0]);

				*/

				if (gTpInfo.sta == 0)

					gTpInfo.sta = 1;

				return 1;

			}

		}

		else

		{

			return 0;

		}

	}

	else

	{

		if(scr_flag == 3)

		{

			scr_x = 0;

			scr_y = 0;

		}

		gTpInfo.sta = 0;

		if(Backlight_flag == 1) Backlight_touch = 0;

		/* debug

			printf("x=%d y=%d\r\n",gTpInfo.x[0],gTpInfo.y[0]);

			printf("gTpInfo.sta=%d \r\n",gTpInfo.sta);

		*/

		return 0;

	}

}

uint8_t LT_TpAdjustScan(void)

{

	if (EPORT_ReadGpioData(EPORT_PIN4) == 0) //&& Rtp_temp==1)

	{

		if (TP_Read_XY2(&gTpInfo.px, &gTpInfo.py))

		{

			gTpInfo.x[0] = gTpInfo.xfac * gTpInfo.px + gTpInfo.xoff;

			gTpInfo.y[0] = gTpInfo.yfac * gTpInfo.py + gTpInfo.yoff;

		}

		if (gTpInfo.x[0] > LCD_XSIZE_TFT)

			gTpInfo.x[0] = LCD_XSIZE_TFT;

		if (gTpInfo.y[0] > LCD_YSIZE_TFT)

			gTpInfo.y[0] = LCD_YSIZE_TFT;

		if (gTpInfo.sta == 0)

			gTpInfo.sta = 1;

		return 1;

	}

	else

	{

		gTpInfo.sta = 0;

		/* debug

			printf("x=%d    y=%d\r\n",gTpInfo.x[0],gTpInfo.y[0]);

		*/

		return 0;

	}

}

// Prompt string

uint8_t *const TP_REMIND_MSG_TBL = (uint8_t *)"Please correct the resistance screen";

// Touch screen calibration

// Get four calibration parameters

uint8_t LT_TpAdjust(void)

{

	uint8_t cnt = 0;

	uint16_t outTime = 0;

	uint16_t d1, d2;

	uint32_t temp1, temp2;

	uint16_t posTemp[2][4] = {0};

	float fac;

	Canvas_Image_Start_address(0);

	Canvas_image_width(LCD_XSIZE_TFT);

	LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

	LT768_Select_Internal_Font_Init(32, 1, 1, 0, 0);

	LT768_Print_Internal_Font_String(40, 40, Red, White, (char *)TP_REMIND_MSG_TBL);

	LT_TpDrawTouchPoint(20, 20, Red);

	while (1)

	{                                                      

		WDT_FeedDog(); //Clear watchdog

		LT_TpAdjustScan();

		if (gTpInfo.sta == 1)

		{

			outTime = 0;

			gTpInfo.sta = 2;

			posTemp[0][cnt] = gTpInfo.px;

			posTemp[1][cnt] = gTpInfo.py;

			cnt++;

			switch (cnt)

			{

			case 1:

				LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

				LT_TpDrawTouchPoint(LCD_XSIZE_TFT - 20, 20, Red);

				break;

			case 2:

				LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

				LT_TpDrawTouchPoint(20, LCD_YSIZE_TFT - 20, Red);

				break;

			case 3:

				LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

				LT_TpDrawTouchPoint(LCD_XSIZE_TFT - 20, LCD_YSIZE_TFT - 20, Red);

				break;

			case 4: 

				temp1 = abs(posTemp[0][0] - posTemp[0][1]);

				temp2 = abs(posTemp[1][0] - posTemp[1][1]);

				temp1 *= temp1;

				temp2 *= temp2;

				d1 = sqrt(temp1 + temp2);

				temp1 = abs(posTemp[0][2] - posTemp[0][3]);

				temp2 = abs(posTemp[1][2] - posTemp[1][3]);

				temp1 *= temp1;

				temp2 *= temp2;

				d2 = sqrt(temp1 + temp2);

				fac = (float)d1 / d2;

				if (fac < 0.95f || fac > 1.05f || d1 == 0 || d2 == 0)

				{

					cnt = 0;

					LT_TpDrawTouchPoint(LCD_XSIZE_TFT - 20, LCD_YSIZE_TFT - 20, White);

					LT_TpDrawTouchPoint(20, 20, Red);

					LT768_Print_Internal_Font_String(200, 180, Red, White, "Check Failure,Please recheck!");

					continue;

				}

				// Calculate the ratio of the left and right sides

				temp1 = abs(posTemp[0][0] - posTemp[0][2]);

				temp2 = abs(posTemp[1][0] - posTemp[1][2]);

				temp1 *= temp1;

				temp2 *= temp2;

				d1 = sqrt(temp1 + temp2);

				temp1 = abs(posTemp[0][1] - posTemp[0][3]);

				temp2 = abs(posTemp[1][1] - posTemp[1][3]);

				temp1 *= temp1;

				temp2 *= temp2;

				d2 = sqrt(temp1 + temp2);

				if (fac < 0.95f || fac > 1.05f || d1 == 0 || d2 == 0)

				{

					cnt = 0;

					LT_TpDrawTouchPoint(LCD_XSIZE_TFT - 20, LCD_YSIZE_TFT - 20, White);

					LT_TpDrawTouchPoint(20, 20, Red);

					LT768_Print_Internal_Font_String(200, 180, Red, White, "Check Failure,Please recheck!");

					continue;

				}

				// 计算相对侧的长度比例

				temp1 = abs(posTemp[0][0] - posTemp[0][3]);

				temp2 = abs(posTemp[1][0] - posTemp[1][3]);

				temp1 *= temp1;

				temp2 *= temp2;

				d1 = sqrt(temp1 + temp2);

				temp1 = abs(posTemp[0][1] - posTemp[0][2]);

				temp2 = abs(posTemp[1][1] - posTemp[1][2]);

				temp1 *= temp1;

				temp2 *= temp2;

				d2 = sqrt(temp1 + temp2);

				fac = (float)d1 / d2;

				if (fac < 0.95f || fac > 1.05f || d1 == 0 || d2 == 0) 

				{

					cnt = 0;

					LT_TpDrawTouchPoint(LCD_XSIZE_TFT - 20, LCD_YSIZE_TFT - 20, White);

					LT_TpDrawTouchPoint(20, 20, Red);

					LT768_Print_Internal_Font_String(200, 180, Red, White, "Check Failure,Please recheck!");

					continue;

				}

				/* If the ratio of the upper and lower sides, the ratio of the left and right sides, 

					and the ratio of the diagonal side are all within the range, the four correction points meet the requirements*/

				gTpInfo.xfac = (float)(LCD_XSIZE_TFT - 40) / (posTemp[0][1] - posTemp[0][0]);

				gTpInfo.xoff = (LCD_XSIZE_TFT - gTpInfo.xfac * (posTemp[0][1] + posTemp[0][0])) / 2;

				gTpInfo.yfac = (float)(LCD_YSIZE_TFT - 40) / (posTemp[1][2] - posTemp[1][0]);

				gTpInfo.yoff = (LCD_YSIZE_TFT - gTpInfo.yfac * (posTemp[1][2] + posTemp[1][0])) / 2;

				gTpxfac.xfac = gTpInfo.xfac;

				gTpxoff.xoff = gTpInfo.xoff;

				gTpyfac.yfac = gTpInfo.yfac;

				gTpyoff.yoff = gTpInfo.yoff;

				LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

				LT768_Print_Internal_Font_String(200, 180, Red, White, "Touch Screen Adjust OK!"); // Calibration successful

				DelayMS(1000);

				//								printf("%f",gTpInfo.xfac);

				//								printf("%f",gTpInfo.xoff);

				//								printf("%f",gTpInfo.yfac);

				//								printf("%f",gTpInfo.yoff);

				// Save 4 parameters

				LT_TpSaveAdjdata();

				return 1;

			}

		}

		DelayMS(10);

		outTime++;

		if (outTime > 4000)

		{

			// Get the 4 parameters previously saved

			LT_TpGetAdjdata();

			LT768_DrawSquare_Fill(0, 0, LCD_XSIZE_TFT, LCD_YSIZE_TFT, White);

			LT768_Print_Internal_Font_String(200, 180, Red, White, "Touch Screen Adjust Failure!"); // Calibration failed

			return 1;

		}

	}

}

uint8_t LT_TpInit(void)

{

	RTP_io_Init();

	DelayMS(10);

	if (LT_TpGetAdjdata() != 1)

	{

		Display_ON();

		DelayMS(100);

		LT768_PWM1_Init(1, 0, 5, 800, 450);

		Rtp_Cor = 1;

		LT_TpAdjust();

	}

	Rtp_Cor = 0;

	TP_Read_XY2(&gTpInfo.px, &gTpInfo.py);

	gTpInfo.scan = LT_TpScan;

	return 1;

}