↑ ↓

7" SSD1963 Dokunmatik Ekran Hassasiyeti

Başlatan kimlenbu, 17 Nisan 2014, 14:36:58

Yazdır
Aşağı git
Kullanıcı Eylemleri

kimlenbu

17 Nisan 2014, 14:36:58 Son düzenlenme: 17 Nisan 2014, 14:44:34 kimlenbu
Selamlar,

XPT2046 dokunmatik sensörü kullanan ekranda nette dolanan standart dokunmatik kütüphanesini kullanıyorum. Ekrana dokunduğumda dokunduğum noktanın çevresine de dokunulmuş gibi algılıyor. Bu sanırım rezistif ekranın kötü yanı. Aşağıdaki fotoğrafta 4 adet dokunmaya ait işaretler var.

Dokunulan noktaya 10x10 piksellik yeşil kareler çizdirince sonuç bu, sadece 4 noktaya dokunuldu.

Yaptıklarım :

40-50 okuma bekleyip, dokunmanın kararlı hale gelmesini bekledim, olmadı.
40-50 örnek alıp x ve y koordinatlarının ortalamasını aldım, olmadı.(Ekran 800x480 olmasına rağmen 1800 gibi değerler okuduğu oluyordu, bunların da kontrolünü yaparak ortalama aldım, gene olmadı.)

Dokunulan noktadan maksimum 5-10 pixel şaşacak şekilde bir hassasiyeti nasıl sağlarım ?


/*********************************************************************************************************
*
* File                : TouchPanel.c
* Hardware Environment: 
* Build Environment   : RealView MDK-ARM  Version: 4.20
* Version             : V1.0
* By                  : 
*
*                                  (c) Copyright 2005-2011, WaveShare
*                                       http://www.waveshare.net
*                                          All Rights Reserved
*
*********************************************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "TouchPanel.h"
#include "Tpconfig.h"
#include "SSD1963.h"

/* Private variables ---------------------------------------------------------*/
Matrix matrix ;
Coordinate  display ;


Coordinate ScreenSample[3];

// Coordinate DisplaySample[3] = {
//                                 { 400,  432 },
// 																 { 80, 240},
//                                 { 720,42}
// 	                          };

// Coordinate DisplaySample[3] = {
//                                 { 50,  45 },
// 																{ 290, 100},
//                                 { 160,210}
// 	                          };

// Coordinate DisplaySample[3] = {
//                                 { 50,  45 },
// 																{ 750, 220},
//                                 { 400,410}
// 	                          };

// Coordinate DisplaySample[3] = {
//                                 { 50,  240 },
// 																{ 700,410},
// 																{ 750, 50}
//                                 
// 	                          };

// Coordinate DisplaySample[3] = {
//                                 { 50,  240 },
// 																{ 700,410},
// 																{ 370, 55}
//                                 
// 	                          };

Coordinate DisplaySample[3] = {
                                { 100,  100 },
																{ 700,240},
																{ 400, 410}
                                
	                          };
/* Private define ------------------------------------------------------------*/
#define THRESHOLD 2


/*******************************************************************************
* Function Name  : ADS7843_SPI_Init
* Description    : 
* Input          : None
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
static void ADS7843_SPI_Init(void) 
{ 
  SPI_InitTypeDef SPI_InitStruct;	
													//RCC_APB1Periph_SPI2
  RCC_APB1PeriphClockCmd(Open_RCC_SPI,ENABLE);	
								//SPI2
  SPI_I2S_DeInit(Open_SPI);
  /* Open_SPI Config -------------------------------------------------------------*/ 
  SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; 
  SPI_InitStruct.SPI_Mode = SPI_Mode_Master; 
  SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; 
  SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low; 
  SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge; 
  SPI_InitStruct.SPI_NSS = SPI_NSS_Soft; 
  SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32; 
  SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB; 
  SPI_InitStruct.SPI_CRCPolynomial = 7; 
						//SPI2
  SPI_Init(Open_SPI, &SPI_InitStruct);
					//SPI2
  SPI_Cmd(Open_SPI, ENABLE); 
} 

/*******************************************************************************
* Function Name  : TP_Init
* Description    : 
* Input          : None
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
void TP_Init(void) 
{ 

	GPIO_InitTypeDef GPIO_InitStructure;
												//RCC_AHB1Periph_GPIOB   RCC_AHB1Periph_GPIOB     RCC_AHB1Periph_GPIOB
	RCC_AHB1PeriphClockCmd(Open_SPI_SCK_GPIO_CLK | Open_SPI_MISO_GPIO_CLK | Open_SPI_MOSI_GPIO_CLK,ENABLE);
											//RCC_AHB1Periph_GPIOC RCC_AHB1Periph_GPIOC
	RCC_AHB1PeriphClockCmd(Open_TP_CS_CLK | Open_TP_IRQ_CLK,ENABLE);
	                  //RCC_APB1Periph_SPI2
	Open_SPI_CLK_INIT(Open_RCC_SPI,ENABLE);
									  //GPIOB									GPIO_PinSource13      GPIO_AF_SPI2
	GPIO_PinAFConfig(Open_SPI_SCK_GPIO_PORT,  Open_SPI_SCK_SOURCE,  Open_GPIO_AF_SPI);
									//GPIOB                   GPIO_PinSource14      GPIO_AF_SPI2
	GPIO_PinAFConfig(Open_SPI_MISO_GPIO_PORT, Open_SPI_MISO_SOURCE, Open_GPIO_AF_SPI);
	                //GPIOB                   GPIO_PinSource15      GPIO_AF_SPI2
	GPIO_PinAFConfig(Open_SPI_MOSI_GPIO_PORT, Open_SPI_MOSI_SOURCE, Open_GPIO_AF_SPI);
																//GPIO_Pin_13
	GPIO_InitStructure.GPIO_Pin = Open_SPI_SCK_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP;  
	GPIO_Init(Open_SPI_SCK_GPIO_PORT, &GPIO_InitStructure); // GPIOB

	GPIO_InitStructure.GPIO_Pin = Open_SPI_MISO_PIN; //GPIO_Pin_14
	GPIO_Init(Open_SPI_MISO_GPIO_PORT, &GPIO_InitStructure); // GPIOB

	GPIO_InitStructure.GPIO_Pin = Open_SPI_MOSI_PIN;  //GPIO_Pin_15
	GPIO_Init(Open_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure); // GPIOB


  /* TP_CS  */
  GPIO_InitStructure.GPIO_Pin = Open_TP_CS_PIN; //GPIO_Pin_4
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(Open_TP_CS_PORT, &GPIO_InitStructure); //GPIOC

  
    /*TP_IRQ */
    GPIO_InitStructure.GPIO_Pin = Open_TP_IRQ_PIN;  //GPIO_Pin_5
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN ;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_Init(Open_TP_IRQ_PORT, &GPIO_InitStructure);	//GPIOC


  	TP_CS(1); 
  	ADS7843_SPI_Init(); 
} 





/*******************************************************************************
* Function Name  : DelayUS
* Description    : 
* Input          : - cnt:
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/

static void DelayUS(vu32 cnt)
{
  uint16_t i;
  for(i = 0;i<cnt;i++)
  {
     uint8_t us = 12;
     while (us--)
     {
       ;   
     }
  }
}


/*******************************************************************************
* Function Name  : WR_CMD
* Description    : 
* Input          : - cmd: 
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
static void WR_CMD (uint8_t cmd)  
{ 
  /* Wait for SPI3 Tx buffer empty */ 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_TXE) == RESET); 
  /* Send SPI3 data */ 
  SPI_I2S_SendData(Open_SPI,cmd); 
  /* Wait for SPI3 data reception */ 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_RXNE) == RESET); 
  /* Read Open_SPI received data */ 
  SPI_I2S_ReceiveData(Open_SPI); 
} 



/*******************************************************************************
* Function Name  : RD_AD
* Description    : 
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
static int RD_AD(void)  
{ 
  unsigned short buf,temp; 
  /* Wait for Open_SPI Tx buffer empty */ 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_TXE) == RESET); 
  /* Send Open_SPI data */ 
  SPI_I2S_SendData(Open_SPI,0x0000); 
  /* Wait for SPI3 data reception */ 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_RXNE) == RESET); 
  /* Read Open_SPI received data */ 
  temp=SPI_I2S_ReceiveData(Open_SPI); 
  buf=temp<<8; 
  DelayUS(1); 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_TXE) == RESET); 
  /* Send Open_SPI data */ 
  SPI_I2S_SendData(Open_SPI,0x0000); 
  /* Wait for Open_SPI data reception */ 
  while (SPI_I2S_GetFlagStatus(Open_SPI, SPI_I2S_FLAG_RXNE) == RESET); 
  /* Read Open_SPI received data */ 
  temp=SPI_I2S_ReceiveData(Open_SPI); 
  buf |= temp; 
  buf>>=3; 
  buf&=0xfff; 
  return buf; 
} 


/*******************************************************************************
* Function Name  : Read_X
* Description    : Read ADS7843 ADC X 
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
int Read_X(void)  
{  
  int i; 
  TP_CS(0); 
  DelayUS(1); 
  WR_CMD(CHX); 
  DelayUS(1); 
  i=RD_AD(); 
  TP_CS(1); 
  return i;    
} 

/*******************************************************************************
* Function Name  : Read_Y
* Description    : Read ADS7843 ADC Y
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
int Read_Y(void)  
{  
  int i; 
  TP_CS(0); 
  DelayUS(1); 
  WR_CMD(CHY); 
  DelayUS(1); 
  i=RD_AD(); 
  TP_CS(1); 
  return i;     
} 


/*******************************************************************************
* Function Name  : TP_GetAdXY
* Description    : Read ADS7843
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
void TP_GetAdXY(int *x,int *y)  
{ 
  int adx,ady; 
  adx=Read_X(); 
  DelayUS(1); 
  ady=Read_Y(); 
  *x=adx; 
  *y=ady; 
} 

/*******************************************************************************
* Function Name  : TP_DrawPoint
* Description    : 
* Input          : - Xpos: Row Coordinate
*                  - Ypos: Line Coordinate 
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
void TP_DrawPoint(uint16_t Xpos,uint16_t Ypos)
{
	SSD1963_LCD_DrawPoint(Xpos,Ypos);     /* Center point */
  SSD1963_LCD_DrawPoint(Xpos+1,Ypos);
  SSD1963_LCD_DrawPoint(Xpos,Ypos+1);
  SSD1963_LCD_DrawPoint(Xpos+1,Ypos+1);	
}	

/*******************************************************************************
* Function Name  : DrawCross
* Description    : 
* Input          : - Xpos: Row Coordinate
*                  - Ypos: Line Coordinate 
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
void DrawCross(uint16_t Xpos,uint16_t Ypos)
{
  SSD1963_LCD_DrawLine(Xpos-15,Ypos,Xpos-2,Ypos,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos+2,Ypos,Xpos+15,Ypos,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos,Ypos-15,Xpos,Ypos-2,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos,Ypos+2,Xpos,Ypos+15,BEYAZ);
  
  SSD1963_LCD_DrawLine(Xpos-15,Ypos+15,Xpos-7,Ypos+15,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos-15,Ypos+7,Xpos-15,Ypos+15,BEYAZ);

  SSD1963_LCD_DrawLine(Xpos-15,Ypos-15,Xpos-7,Ypos-15,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos-15,Ypos-7,Xpos-15,Ypos-15,BEYAZ);

  SSD1963_LCD_DrawLine(Xpos+7,Ypos+15,Xpos+15,Ypos+15,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos+15,Ypos+7,Xpos+15,Ypos+15,BEYAZ);

  SSD1963_LCD_DrawLine(Xpos+7,Ypos-15,Xpos+15,Ypos-15,BEYAZ);
  SSD1963_LCD_DrawLine(Xpos+15,Ypos-15,Xpos+15,Ypos-7,BEYAZ);	   	
}	
	
/*******************************************************************************
* Function Name  : Read_Ads7846
* Description    : Get TouchPanel X Y
* Input          : None
* Output         : None
* Return         : Coordinate *
* Attention		 : None
*******************************************************************************/
Coordinate *Read_Ads7846(void)
{
  static Coordinate  screen;
  int m0,m1,m2,TP_X[1],TP_Y[1],temp[3];
  uint8_t count=0;
  int buffer[2][9]={{0},{0}};
  
  do
  {		   
  TP_GetAdXY(TP_X,TP_Y);  
	buffer[0][count]=TP_X[0];  
	buffer[1][count]=TP_Y[0];
	count++;  
  }
  while(!TP_INT_IN&& count<9);  /* TP_INT_IN  */
  if(count==9)   /* Average X Y  */ 
  {
	/* Average X  */
  temp[0]=(buffer[0][0]+buffer[0][1]+buffer[0][2])/3;
	temp[1]=(buffer[0][3]+buffer[0][4]+buffer[0][5])/3;
	temp[2]=(buffer[0][6]+buffer[0][7]+buffer[0][8])/3;

	m0=temp[0]-temp[1];
	m1=temp[1]-temp[2];
	m2=temp[2]-temp[0];

	m0=m0>0?m0:(-m0);
  m1=m1>0?m1:(-m1);
	m2=m2>0?m2:(-m2);

	if( m0>THRESHOLD  &&  m1>THRESHOLD  &&  m2>THRESHOLD ) return 0;

	if(m0<m1)
	{
	  if(m2<m0) 
	    screen.x=(temp[0]+temp[2])/2;
	  else 
	    screen.x=(temp[0]+temp[1])/2;	
	}
	else if(m2<m1) 
	  screen.x=(temp[0]+temp[2])/2;
	else 
	  screen.x=(temp[1]+temp[2])/2;

	/* Average Y  */
  temp[0]=(buffer[1][0]+buffer[1][1]+buffer[1][2])/3;
	temp[1]=(buffer[1][3]+buffer[1][4]+buffer[1][5])/3;
	temp[2]=(buffer[1][6]+buffer[1][7]+buffer[1][8])/3;
	m0=temp[0]-temp[1];
	m1=temp[1]-temp[2];
	m2=temp[2]-temp[0];
	m0=m0>0?m0:(-m0);
	m1=m1>0?m1:(-m1);
	m2=m2>0?m2:(-m2);
	if(m0>THRESHOLD&&m1>THRESHOLD&&m2>THRESHOLD) return 0;

	if(m0<m1)
	{
	  if(m2<m0) 
	    screen.y=(temp[0]+temp[2])/2;
	  else 
	    screen.y=(temp[0]+temp[1])/2;	
    }
	else if(m2<m1) 
	   screen.y=(temp[0]+temp[2])/2;
	else
	   screen.y=(temp[1]+temp[2])/2;

	return &screen;
  }  
  return 0; 
}
	 

/*******************************************************************************
* Function Name  : setCalibrationMatrix
* Description    : Calculate K A B C D E F
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
FunctionalState setCalibrationMatrix( Coordinate * displayPtr,
                          Coordinate * screenPtr,
                          Matrix * matrixPtr)
{

  FunctionalState retTHRESHOLD = ENABLE ;
  /* K£½(X0£­X2) (Y1£­Y2)£­(X1£­X2) (Y0£­Y2) */
  matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) - 
                       ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
  if( matrixPtr->Divider == 0 )
  {
    retTHRESHOLD = DISABLE;
  }
  else
  {
    /* A£½((XD0£­XD2) (Y1£­Y2)£­(XD1£­XD2) (Y0£­Y2))£¯K	*/
    matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) - 
                    ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
	/* B£½((X0£­X2) (XD1£­XD2)£­(XD0£­XD2) (X1£­X2))£¯K	*/
    matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) - 
                    ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
    /* C£½(Y0(X2XD1£­X1XD2)+Y1(X0XD2£­X2XD0)+Y2(X1XD0£­X0XD1))£¯K */
    matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
                    (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
                    (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
    /* D£½((YD0£­YD2) (Y1£­Y2)£­(YD1£­YD2) (Y0£­Y2))£¯K	*/
    matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) - 
                    ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
    /* E£½((X0£­X2) (YD1£­YD2)£­(YD0£­YD2) (X1£­X2))£¯K	*/
    matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) - 
                    ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
    /* F£½(Y0(X2YD1£­X1YD2)+Y1(X0YD2£­X2YD0)+Y2(X1YD0£­X0YD1))£¯K */
    matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
                    (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
                    (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
  }
  return( retTHRESHOLD ) ;
}

/*******************************************************************************
* Function Name  : getDisplayPoint
* Description    : Touch panel X Y to display X Y
* Input          : None
* Output         : None
* Return         : 
* Attention		 : None
*******************************************************************************/
FunctionalState getDisplayPoint(Coordinate * displayPtr,
                     Coordinate * screenPtr,
                     Matrix * matrixPtr )
{
  FunctionalState retTHRESHOLD =ENABLE ;

  if( matrixPtr->Divider != 0 )
  {
    /* XD = AX+BY+C */        
    displayPtr->x = ( (matrixPtr->An * screenPtr->x) + 
                      (matrixPtr->Bn * screenPtr->y) + 
                       matrixPtr->Cn 
                    ) / matrixPtr->Divider ;
	/* YD = DX+EY+F */        
    displayPtr->y = ( (matrixPtr->Dn * screenPtr->x) + 
                      (matrixPtr->En * screenPtr->y) + 
                       matrixPtr->Fn 
                    ) / matrixPtr->Divider ;
  }
  else
  {
    retTHRESHOLD = DISABLE;
  }
  return(retTHRESHOLD);
} 

/*******************************************************************************
* Function Name  : delay_ms
* Description    : Delay Time
* Input          : - cnt: Delay Time
* Output         : None
* Return         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
static void delay_ms(uint16_t ms)    
{ 
	uint16_t i,j; 
	for( i = 0; i < ms; i++ )
	{ 
		for( j = 0; j < 0xffff; j++ );
	}
} 

/*******************************************************************************
* Function Name  : TouchPanel_Calibrate
* Description    : 
* Input          : None
* Output         : None
* Return         : None
* Attention		 : None
*******************************************************************************/
void TouchPanel_Calibrate(void)
{
//   uint8_t i;
//   Coordinate * Ptr;
// 	uint8_t temp[50];

//   for(i=0;i<3;i++)
//   {
//    SSD1963_LCD_Clear(BLACK);
//    SSD1963_LCD_ShowString(44,10,"Touch crosshair to calibrate",BEYAZ,KOYUGRI);
//    delay_ms(300);
//    DrawCross(DisplaySample[i].x,DisplaySample[i].y);
//    do
//    {
//      Ptr=Read_Ads7846();
//    }
//    while( Ptr == (void*)0 );
//    ScreenSample[i].x= Ptr->x; ScreenSample[i].y= Ptr->y;
//   }
// 	sprintf(temp,"X1:%4d,Y1:%4d,X2:%4d,Y2:%4dX3:%4d,Y3:%4d",ScreenSample[0].x,ScreenSample[0].y,ScreenSample[1].x,ScreenSample[1].y,ScreenSample[2].x,ScreenSample[2].y);
// 	SSD1963_LCD_ShowString(0,300,(uint8_t*)temp,BEYAZ,SIYAH);
// 	delay_ms(30000);
	ScreenSample[0].x=1124;
	ScreenSample[0].y=643;
	ScreenSample[1].x=2078;
	ScreenSample[1].y=3234;
	ScreenSample[2].x=3310;
	ScreenSample[2].y=1927;
  setCalibrationMatrix( &DisplaySample[0],&ScreenSample[0],&matrix );
  SSD1963_LCD_Clear(BLACK);
} 

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

Goo

#1
17 Nisan 2014, 14:52:17
Kullandığınız kontrolörde var mı bilmiyorum ama bunun için içerisinde filtreleme katsayıları olması gerekiyor.

diot

#2
17 Nisan 2014, 15:37:02
Ben okuma yaparken max min dışında gelen değerleri, değerlendirme dışı bırakıyorum ve ayrıca 10 okumanın ortalamasını alıp kullanıyorum. birde 2. bir filitreleme yapılabilir mesela %10 dışı gelen değerler geçersiz sayılabilir.

Veli B.

#3
18 Nisan 2014, 03:18:37
Beslemenizi kontrol edin. ADC referansı ripple sebebi ile yüzüyor gibi. Scop ile bakmak lazım.

kimlenbu

#4
18 Nisan 2014, 14:10:11
dokunmatik kalibrasyonunu tekrar yaptım, referans nokta seçimim yeterince iyi değilmiş youtubedan bakıp 3 referans noktasını tekrar belirledim. 30 örnek alıp ortalama hesaplattım, dokunulacak koordinatları birbirinden uzaklaştırdım, geçici olarak çözüldü sorun. Öneriler için teşekkür ederim.

M_B

#5
12 Haziran 2014, 14:33:46
Merhaba arkadaslar;
7" TFT üzerinde yarım kalan touch kısmına baslamış bulunmaktayım. Yalnız henüz tam manasıyla kontrol edemedim.
Takıldığım nokta.
yukarda bulunan driveri kullanıyorum.

TouchPanel_Calibrate(); fonksiyonu nu kullanarak kalıbre ediyorum. Ekrana ince uclu kalemle dokunduğumda dokunulan yerde
noktalar meydana geliyor. Ara sıra ise dokunduğum yerde ve  biraz uzağında  cıkıyor.
Kalibre icin ise
@Kimlenbu hocamın vermiş olduğu 
Coordinate DisplaySample[3] = {
   
                              {  50,  45 },
                              { 400, 390 },
                              { 700, 240 }
                              };

kullanarak  aşağıdaki verileri elde ettim.
      ScreenSample[0].x=350;
	ScreenSample[0].y=579;
	
	ScreenSample[1].x=2096;
	ScreenSample[1].y=3270;
	
	ScreenSample[2].x=3565;
	ScreenSample[2].y=2094;

Bu verilerle kalemi dokunduğum yerde nokta cıkıyor yanı kalıbre tamam gibi yalnız
aşağıdaki gibi bir resmi istediğim noktaya bastıktan sonra ilgili resme dokunduğumda
if sartın icerisindeki kordinatlara denk gelmiyor.  anlatmaya çalıştığım kod alt kısımda

TouchPanel_Calibrate();
	SSD1963_LCD_BMP(275, 150, 64,64, gImage_off);// 275,150 noktas1 ve 64,64 boyutunda 
 
 
  while (1)
  {	
	      getDisplayPoint(&display, Read_Ads7846(), &matrix ) ;
				
				 if((display.x>200)&&(display.x<275)&&(display.y>90)&&(display.y<150)) 
							{
								SSD1963_LCD_BMP(375, 250, 64,64, gImage_off);
							}
	   	  SSD1963_Draw_Circle(display.x,display.y, 2);
		
  }	
}


İmkanın sınırlarını görmek için imkansızı denemek lazım.                                                             Fatih Sultan Mehmet

kimlenbu

#6
12 Haziran 2014, 15:35:23 Son düzenlenme: 12 Haziran 2014, 15:44:12 kimlenbu
Resim 275,150 koordinatlarında, 64x64pixel

Yani kontrol etmen gereken alan şu : (x1,y1,x2,y2) = 275,150,339,214

zaten koduna göre dokunulduğunda da farklı koordinata basıyorsun resmi.

Ekleme : LCD init kodlarına göre koordinat başlangıcı sol üst köşe (0,0) veya sol alt köşe (0,0) olabiliyor, buna da dikkat et. Bende şu şekilde (sol üst köşe 0,0 olacak şekilde kullanıyorum) :

LCD_WriteCommand(0x0036); //rotation
	LCD_WriteData(0x0000);///////////////////////////Ekran1 rotate icin kullaniliyor.
 // 80,81,82,83

M_B

#7
12 Haziran 2014, 15:42:30
Alıntı yapılan: kimlenbu - 12 Haziran 2014, 15:35:23
Resim 275,150 koordinatlarında, 64x64pixel

Yani kontrol etmen gereken alan şu : (x1,y1,x2,y2) = 275,150,339,214

zaten koduna göre dokunulduğunda da farklı koordinata basıyorsun resmi.
Haklısınız.
Az once masadan kalkıp dolastım ve aklıma geldi Aynen dediğiniz gibi.
olması gereken
if((display.x>275)&&(display.x<339)&&(display.y>150)&&(display.y<214))
                  {
                  SSD1963_LCD_BMP(375, 250, 64,64, gImage_off);
                  }

Bu ayrıntıyı nasıl kacırdım bilmiyorum ama bundan bir onceki 3.2" ekranım da bu tur bir mantık kurmus ve calıstırmıstım.

Ortalama almak istesem nasıl alabilirim.  ( Bu ara sorularım cok basite kacıyor ama kafam o kadar doluki )

İmkanın sınırlarını görmek için imkansızı denemek lazım.                                                             Fatih Sultan Mehmet

kimlenbu

#8
12 Haziran 2014, 15:53:17
Ortalama almak için ekrana dokunulmuş mu diye ekranın TP_IRQ ucunu kontrol etmen lazım. Ben hassasiyet yeterli olduğu için kullanmıyorum.

   
if(GPIOC->IDR & 0x0020)
	{
		//TouchPad'e DOKUNULMADI
		DokunmatikSayac=0;
	}
	else
	{
		//TuchPad'e DOKUNULDU
		
		DokunmatikSayac+=1;
		if(DokunmatikSayac<100)
		{
// 			if(display.x<=800){DokunmatikXOrt+=display.x;DokunmatikXCount+=1;}
// 			if(display.y<=480){DokunmatikYOrt+=display.y;DokunmatikYCount+=1;}
			return;
		}
		else
		{
// 			display.x=DokunmatikXOrt/DokunmatikXCount;
// 			display.y=DokunmatikYOrt/DokunmatikYCount;
// 			DokunmatikGoster();
		}
	}
Yazdır
Yukarı git
Kullanıcı Eylemleri
▲