开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
paneldrv.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：30k
源码类别：

uCOS

开发平台：

C/C++

paneldrv.c：源码内容
  2. #include "paneldrv.h"
  3. #include "_define.h"
  4. #include "panel.h"
  5. #include "cpu_clock.h"
  6. #include "cpu.h"
  7. #include "cpu_int.h"
  8. #include "lcd.h"
  10. #define _TOUCH_RESISTER_CHECK_
  11. #ifdef _TOUCH_RESISTER_CHECK_
  12. #define TOUCH_RES_MAX 900
  13. enum
  14. { TOUCH_NO_ACTIVE = 0,
  15. TOUCH_DOWN_ACTIVE,
  16. TOUCH_MOVE_ACTIVE,
  17. TOUCH_MOVE_NO_ACTIVE,
  18. };
  19. #endif
  22. #define           PANRECLEN 5
  23. //#define  PANEL_ROTATE_180
  24. PenQueue  gPenQueue;
  25. PANEL_STRUC tchscr_pen,tchscr,penrectif[PANRECLEN];  
  26. PANEL_STRUC tchscrback;
  27. unsigned char  bTouchCheck4KeyState = 0;
  28. PANELQUEUE   PanelVar;
  29. TCHSCR_RECTIF  tchscr_rectif;
  30. PANEL_STRUC tchscr_pen;
  31. //#define      _NEW_TOUCHPANEL_
  32. #define TARGET_RAD 80
  33. #define  PEN_ERR 999
  34. //#define PRSCVL   19
  35. unsigned short PRSCVL;
  36. #define XDATA_MIN  130//120
  37. #define XDATA_MAX  912//900
  38. #define YDATA_MIN  168//145
  39. #define YDATA_MAX  930//915
  41. #ifndef _NEW_TOUCHPANEL_
  42. #define TOUCHPEN_XY_SWAP
  43. #endif
  45. #define  XLCD_POS(data) ( (int)((LCD_XSIZE*((data)-XDATA_MIN)) /(XDATA_MAX-XDATA_MIN)))
  46. #define  YLCD_POS(data) (( (int)(LCD_YSIZE*((data)-YDATA_MIN)/(YDATA_MAX-YDATA_MIN)) ))
  47. unsigned long g_tsnum=0;
  48. int  g_Lastx,g_Lasty;
  49. int       g_MouseUp=1;
  50. void   TouchPanelISR(void);
  52. #ifdef _TOUCH_RESISTER_CHECK_
  53. int g_touch_down_status;
  54. int g_xdata;
  55. int IsTouchActive()
  56. {
  57. int g_touch_res_p,g_touch_res_m,xposition;
  58. int g_touch_res_value;
  59. //if(!g_touch_down_status)
  60. {
  61. #if 0
  62. rADCTSC=(1<<6)|(1<<5);         //XM,YP enable
  63. rADCDLY=40000;                 
  64. PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff);
  65. rADCCON=(1<<14)+((PRSCVL-1)<<6)+(5<<3);   
  66. rADCCON|=0x1;                   //start ADC
  68. while(rADCCON & 0x1); //check if Enable_start is low
  69. while(!(rADCCON & 0x8000));        //check if EC(End of Conversion) flag is high, This line is necessary~!!
  70. xposition = (rADCDAT0&0x3ff);
  71. #else
  72. xposition = g_xdata;
  73. #endif
  74. rADCTSC= (1<<4)|(1<<5);         //XM,YP enable
  75. rADCDLY=4000;                 
  76. PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff);
  77. rADCCON=(1<<14)+((PRSCVL-1)<<6)+(7<<3);   
  78. rADCCON|=0x1;                   //start ADC
  80. while(rADCCON & 0x1); //check if Enable_start is low
  81. while(!(rADCCON & 0x8000));        //check if EC(End of Conversion) flag is high, This line is necessary~!!
  82. g_touch_res_m = (rADCDAT0&0x3ff);
  84. //rADCTSC=(1<<6)|(1<<5);         //XM,YP enable
  85. //rADCDLY=40000;                 
  86. //PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff);
  87. rADCCON=(1<<14)+((PRSCVL-1)<<6)+(4<<3);   
  88. rADCCON|=0x1;                   //start ADC
  90. while(rADCCON & 0x1); //check if Enable_start is low
  91. while(!(rADCCON & 0x8000));        //check if EC(End of Conversion) flag is high, This line is necessary~!!
  92. g_touch_res_p = (rADCDAT0&0x3ff);
  93. rADCDLY=40000;
  94. g_touch_res_value = (float)((g_touch_res_p/g_touch_res_m)-1)*xposition/1024.0*400;
  95. if( g_touch_res_value > TOUCH_RES_MAX )
  96. {
  97. if(g_touch_down_status == TOUCH_MOVE_ACTIVE || g_touch_down_status == TOUCH_DOWN_ACTIVE)
  98. {
  99. g_touch_down_status = TOUCH_MOVE_NO_ACTIVE;
  100. }
  101. return 0;
  102. }
  103. else
  104. {
  105. if(g_touch_down_status == TOUCH_DOWN_ACTIVE || g_touch_down_status == TOUCH_MOVE_NO_ACTIVE)
  106. {
  107. g_touch_down_status = TOUCH_MOVE_ACTIVE;
  108. }
  109. else if(g_touch_down_status == TOUCH_NO_ACTIVE)
  110. {
  111. g_touch_down_status = TOUCH_DOWN_ACTIVE;
  112. }
  113. return 1;
  114. }
  115. }
  116. }
  118. #endif
  121. //int   g_pendown=0; //0:down;  1:up
  122. void OpenAdcTs(void)
  123. {
  124.     OpenClock(CLK_ADC);
  125. rADCDLY=50000;                  //Normal conversion mode delay about (1/3.6864M)*50000=13.56ms
  126. PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff); // 5us
  127. rADCCON=(1<<14)+((PRSCVL-1)<<6);   //PRSCVL En, PRSCVL Value
  128. rADCTSC=0xd3;  //Wfait,XP_PU,XP_Dis,XM_Dis,YP_Dis,YM_En
  129. MapInterrupt(BIT_ADC, (unsigned)TouchPanelISR);
  130. //OpenInterrupt(BIT_ADC);
  131. rINTMSK&=~(BIT_ADC);       //ADC Touch Screen Mask bit clear
  132. rINTSUBMSK&=~(BIT_SUB_TC);
  133. }
  135. int    g_pennum=0;
  136. void ScanTs(void)
  137. {
  138. int volatile xdata, ydata;
  139. if(g_MouseUp)
  140. return;
  141. //rADCTSC=0xd3;  //Wfait,XP_PU,XP_Dis,XM_Dis,YP_Dis,YM_En
  142. if(rADCDAT0&0x8000)
  143. {
  144. rADCTSC&=0xff; // Set stylus down interrupt bit
  145. }
  146. rADCTSC=(1<<3)|(1<<2);         //Pull-up disable, Seq. X,Y postion measure.
  147. // saveAdcdly=rADCDLY;
  148. rADCDLY=40000;                 //Normal conversion mode delay about (1/50M)*40000=0.8ms
  149. PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff); // 5us
  150. rADCCON=(1<<14)+((PRSCVL-1)<<6);   //PRSCVL En, PRSCVL Value
  151. rADCCON|=0x1;                   //start ADC
  153. while(rADCCON & 0x1); //check if Enable_start is low
  154. while(!(rADCCON & 0x8000));        //check if EC(End of Conversion) flag is high, This line is necessary~!!
  157. // while(!(rSRCPND & (BIT_ADC)));  //check if ADC is finished with interrupt bit
  158. #ifndef TOUCHPEN_XY_SWAP
  159. ydata=(rADCDAT0&0x3ff);
  160. xdata=(rADCDAT1&0x3ff);
  161. #else
  162. xdata=(rADCDAT0&0x3ff);
  163. ydata=(rADCDAT1&0x3ff);
  164. #endif
  166. #ifdef _TOUCH_RESISTER_CHECK_
  167. g_xdata = xdata;
  168. IsTouchActive();
  170. #endif
  172. #if PANEL_MINMAX_
  173. panel.PanelDotX=g_Lastx;//YLCD_POS(xdata);
  174. panel.PanelDotY=g_Lasty;//XLCD_POS(ydata);
  175. panel.PanelState=TOUCHPEN_MOVE|TOUCHPEN_DOWN;
  176. PutPanelInf(&panel);
  177. g_Lastx=XLCD_POS(xdata);
  178. g_Lasty=YLCD_POS(ydata);
  179. #else 
  180. tchscr.PanelDotX=xdata;
  181. tchscr.PanelDotY=ydata;
  182. if(gbTouchAdjustFlag)
  183. {
  184. if(g_pennum<(PANRECLEN-1))
  185. {
  186. penrectif[++g_pennum]=tchscr;
  187. }
  188. else if(g_pennum==(PANRECLEN-1))
  189. {
  190. tchscr_calcu_pencoord();
  191. #ifdef  PANEL_ROTATE_180
  192. //add  by TH 070404, Rotate TP 180 degree
  193. tchscr_pen.PanelDotX=LCD_XSIZE-tchscr_pen.PanelDotX;
  194. tchscr_pen.PanelDotY=LCD_YSIZE-tchscr_pen.PanelDotY;
  195. #endif
  196. tchscr_pen.PanelState=TOUCHPEN_DOWN;
  197. if((tchscrback.PanelDotX!=PEN_ERR)&&(tchscrback.PanelDotY!=PEN_ERR))
  198. PutPanelInf(&tchscr_pen);
  199. g_pennum++;
  200. }
  202. }
  203. else
  204. {
  205. #ifdef _TOUCH_RESISTER_CHECK_
  206. if(g_touch_down_status == TOUCH_MOVE_ACTIVE )
  207. #endif
  208. {
  209. tchscrback.PanelDotX=g_Lastx;
  210. tchscrback.PanelDotY=g_Lasty;
  211. tchscrback.PanelState=TOUCHPEN_MOVE|TOUCHPEN_DOWN;
  212. if((tchscrback.PanelDotX!=PEN_ERR)&&(tchscrback.PanelDotY!=PEN_ERR))
  213. PutPanelInf(&tchscrback);
  214. tchscr_calcu_pencoord();
  216. #ifdef  PANEL_ROTATE_180
  217. //add  by TH 070404, Rotate TP 180 degree
  218. tchscr_pen.PanelDotX=LCD_XSIZE-tchscr_pen.PanelDotX;
  219. tchscr_pen.PanelDotY=LCD_YSIZE-tchscr_pen.PanelDotY;
  220. #endif
  222. g_Lastx=tchscr_pen.PanelDotX;
  223. g_Lasty=tchscr_pen.PanelDotY;
  224. }
  225. #ifdef _TOUCH_RESISTER_CHECK_
  226. else if(g_touch_down_status == TOUCH_DOWN_ACTIVE )
  227. {
  229. tchscr_calcu_pencoord();
  230. g_Lastx=tchscr_pen.PanelDotX;
  231. g_Lasty=tchscr_pen.PanelDotY;
  232. tchscrback.PanelDotX=g_Lastx;
  233. tchscrback.PanelDotY=g_Lasty;
  234. tchscrback.PanelState=TOUCHPEN_DOWN;
  235. PutPanelInf(&tchscrback);
  237. }
  238. #endif
  239. }
  240. #endif
  242. rADCDLY=40000; 
  243. rADCTSC =0xd3;    //Waiting for interrupt
  244. rADCTSC=rADCTSC|(1<<8); // Detect stylus up interrupt signal.
  247. }
  248. extern void RemoveTimeFunc(void(* function)(void));
  249. unsigned int g_TouchPanelCome=0;
  250. void TouchPanelISR(void)
  251. {
  252. rSUBSRCPND|=BIT_SUB_TC;
  253.  ClearIntLatch (BIT_ADC);
  254.  g_TouchPanelCome=1;
  255.  if((g_tsnum%2))
  256.  {
  257.   g_MouseUp=1;
  258.  }  
  259. }
  262. void   TouchPanelDSR(void)
  263. {
  265. unsigned int saveAdcdly;
  266. int volatile xdata, ydata;
  267. if(rADCDAT0&0x8000)
  268. {
  269. rADCTSC&=0xff; // Set stylus down interrupt bit
  270. }
  272. rADCTSC=(1<<3)|(1<<2);         //Pull-up disable, Seq. X,Y postion measure.
  273. saveAdcdly=rADCDLY;
  274. rADCDLY=40000;                 //Normal conversion mode delay about (1/50M)*40000=0.8ms
  275. PRSCVL = (unsigned short)((GetClock(PCLK)/1000000) & 0xff); // 5us
  276. rADCCON=(1<<14)+((PRSCVL-1)<<6);   //PRSCVL En, PRSCVL Value
  277. rADCCON|=0x1;                   //start ADC
  279. while(rADCCON & 0x1); //check if Enable_start is low
  280. while(!(rADCCON & 0x8000));        //check if EC(End of Conversion) flag is high, This line is necessary~!!
  281. #ifndef TOUCHPEN_XY_SWAP
  282. ydata=(rADCDAT0&0x3ff);
  283. xdata=(rADCDAT1&0x3ff);
  284. #else
  285. xdata=(rADCDAT0&0x3ff);
  286. ydata=(rADCDAT1&0x3ff);
  287. #endif
  290. #ifdef _TOUCH_RESISTER_CHECK_
  291. g_xdata = xdata;
  292. IsTouchActive();
  294. #endif
  297.  rINTSUBMSK&=~(BIT_SUB_TC);
  298.  rINTMSK&=~(BIT_ADC);
  299.  rADCDLY=40000; 
  300.  rADCTSC =0xd3;    //Waiting for interrupt
  301.  if(!(g_tsnum%2))
  302.  {
  303. #ifdef PANEL_MINMAX_
  304. panel.PanelDotX=XLCD_POS(xdata);
  305. panel.PanelDotY=YLCD_POS(ydata);
  306. panel.PanelState=TOUCHPEN_DOWN;
  307. PutPanelInf(&panel);
  308. g_Lastx=panel.PanelDotX;
  309. g_Lasty=panel.PanelDotY;
  310. #else 
  311. tchscr.PanelDotX=xdata;
  312. tchscr.PanelDotY=ydata;
  313. if(gbTouchAdjustFlag)
  314. {
  315. g_pennum=0;
  316. penrectif[g_pennum]=tchscr;
  317. }
  318. else
  319. {
  320. tchscr_calcu_pencoord();
  321. #ifdef PANEL_ROTATE_180
  322. //add  by TH 070404, Rotate TP 180 degree
  323. tchscr_pen.PanelDotX=LCD_XSIZE-tchscr_pen.PanelDotX;
  324. tchscr_pen.PanelDotY=LCD_YSIZE-tchscr_pen.PanelDotY;
  325. #endif
  327. #ifdef _TOUCH_RESISTER_CHECK_
  328. if(g_touch_down_status == TOUCH_DOWN_ACTIVE)
  329. #endif
  330. {
  331. tchscr_pen.PanelState=TOUCHPEN_DOWN;
  332. PutPanelInf(&tchscr_pen);
  333. }
  334. }
  337. g_Lastx=tchscr_pen.PanelDotX;
  338. g_Lasty=tchscr_pen.PanelDotY;
  339. tchscrback.PanelDotX=g_Lastx;
  340. tchscrback.PanelDotY=g_Lasty;
  341. #endif 
  342. rADCTSC=rADCTSC|(1<<8); // Detect stylus up interrupt signal.
  343. g_MouseUp=0;
  344. InsertTimer(20, ScanTs);
  346.  }
  347. else
  348. {
  349. RemoveTimeFunc(ScanTs);
  350. #ifdef PANEL_MINMAX_
  351. panel.PanelState=TOUCHPEN_UP;  
  352. PutPanelInf(&panel);
  353. #else
  355. #ifdef _TOUCH_RESISTER_CHECK_
  356. if((gbTouchAdjustFlag&&(g_pennum>(PANRECLEN-1)))||(!gbTouchAdjustFlag&&(g_touch_down_status != TOUCH_NO_ACTIVE)))
  357. #else
  358. if(gbTouchAdjustFlag&&(g_pennum>(PANRECLEN-1))||(!gbTouchAdjustFlag))
  359. #endif
  360. {
  361. tchscrback.PanelState=TOUCHPEN_UP;  
  362. PutPanelInf(&tchscrback);
  363. #ifdef _TOUCH_RESISTER_CHECK_
  364. g_touch_down_status = TOUCH_NO_ACTIVE;
  365. #endif
  366. }
  367. #endif
  368. }
  369. g_tsnum++;
  371. }
  373. unsigned char CmpRange(unsigned short sx, unsigned short sy, unsigned short tx, unsigned short ty)
  374. {
  375. unsigned short i, j;
  377. i = ModulusMinusValue(tx, sx);
  378. j = ModulusMinusValue(ty, sy);
  380. if( i <= 100 && j <= 100 )
  381. return 1;
  383. return 0;
  384. }
  386. unsigned int g_NTouchpanel=1;
  387. void InitTouchPen(void)
  388. {
  389. gPenQueue.wHead = 0;
  390. gPenQueue.wTail = 0;
  391. gPenQueue.PenState[0].wTouchState = _PEN_UP;
  392. gPenQueue.PenState[0].wTouchX = 0;
  393. gPenQueue.PenState[0].wTouchY = 0; 
  394. OpenAdcTs();
  395. }
  397. TouchPenState GetPenInfo(unsigned short wCurPoint)
  398. {
  399. TouchPenState PenTemp;
  401. PenTemp.wTouchState = gPenQueue.PenState[wCurPoint].wTouchState;
  402. PenTemp.wTouchX = gPenQueue.PenState[wCurPoint].wTouchX;
  403. PenTemp.wTouchY = gPenQueue.PenState[wCurPoint].wTouchY;
  405. return PenTemp;
  406. }
  408. unsigned char ComparePenState(PEN_POINT pt)
  409. {
  410. unsigned short wTail;
  411. TouchPenState PenTemp;
  413. wTail = gPenQueue.wTail;
  414. PenTemp = gPenQueue.PenState[wTail];
  416. // touch same point
  417. if(pt.x == PenTemp.wTouchX && pt.y == PenTemp.wTouchY)
  418. return 0;
  420. return 1;
  421. }
  423. PEN_POINT CurrentPenPos(void)
  424. {
  425. PEN_POINT pt;
  427. pt.x = gwTouchXSite;
  428. pt.y = gwTouchYSite;
  430. return pt;
  431. }
  433. void InitPanelQueue(void)
  434. {
  435. PanelVar.PanelFront = 0;
  436. PanelVar.PanelRear = 0;
  437. PanelVar.PanelBufFull = FALSE;
  438. }
  440. unsigned char GetPanelInf(PANEL_STRUC *panelvar)
  441. {
  443. // panel buffer is not empty
  444. if ( ( PanelVar.PanelFront != PanelVar.PanelRear) )
  445. {
  446. *panelvar = PanelVar.PanelBuf[PanelVar.PanelFront];
  447. PanelVar.PanelFront++;
  449. if ( PanelVar.PanelFront == PANELBUFLEN) 
  450.    PanelVar.PanelFront = 0;
  451.   
  452. return TRUE;
  453.  }
  455. return FALSE;
  456. }
  457. extern  ts_info TsInfo ;
  458. unsigned char PutPanelInf(PANEL_STRUC *panelvar)
  459. {
  462. // BackLightOn();
  463. // jil add, 05/19, set quit flag for fax
  464. if((panelvar->PanelState==TOUCHPEN_DOWN))
  465. StartTouchTone();
  466. if( (PanelVar.PanelRear+1)%PANELBUFLEN != PanelVar.PanelFront)
  467. {
  468. PanelVar.PanelBuf[PanelVar.PanelRear] = *panelvar;
  469. PanelVar.PanelRear++;
  471. if( PanelVar.PanelRear == PANELBUFLEN)
  472.     PanelVar.PanelRear = 0;
  473. if( TsInfo.hdev!=0 && TsInfo.callback!= 0 )
  474. TsInfo.callback(TsInfo.hdev,STATUS_DATA_READY, NULL) ;
  476. return TRUE;  
  477.     }               
  478.     
  479. return FALSE;
  480. }
  482. unsigned char _PeekPanel(PANEL_STRUC *p)
  483. {
  484. // panel buffer is not empty
  485. if ( ( PanelVar.PanelFront != PanelVar.PanelRear) )
  486. {
  488. *p = PanelVar.PanelBuf[PanelVar.PanelFront];
  489. return TRUE;
  490. }
  491. else
  492. return FALSE;
  494. }
  496. unsigned char Is_penexist(void)
  497. {
  498. if ( ( PanelVar.PanelFront != PanelVar.PanelRear))
  499. return TRUE;
  500. else
  501. return FALSE;
  502. }
  505. unsigned char gbTouchAdjustFlag = 0;
  506. void PenAdjustBegin(void)
  507. {
  508. gbTouchAdjustFlag = 1;
  509. }
  511. void PenAdjustEnd(void)
  512. {
  513. gbTouchAdjustFlag = 0;
  514. }
  516.  unsigned char tchscr_adjust_center(  unsigned short lcd_pos_x, unsigned short lcd_pos_y, unsigned short pen_val_x, unsigned short pen_val_y )
  517. {
  518. unsigned long  err2;
  519. unsigned long  rad2;
  521. err2 = (tchscr_pen.PanelDotX-lcd_pos_x)*(tchscr_pen.PanelDotX-lcd_pos_x) +
  522. (tchscr_pen.PanelDotY-lcd_pos_y)*(tchscr_pen.PanelDotY-lcd_pos_y);
  523. rad2 = TARGET_RAD*TARGET_RAD;
  524. if( err2 > rad2 )
  525. return 0;
  526. lcd_pos_x = lcd_pos_x;
  527. lcd_pos_y = lcd_pos_y;
  528. tchscr_rectif.cent_val_x = pen_val_x;
  529. tchscr_rectif.cent_val_y = pen_val_y;
  530. tchscr_rectif.cent_crd_x= LCD_XSIZE/2;
  531. tchscr_rectif.cent_crd_y= LCD_YSIZE/2;
  532. return 1;
  533. }
  535. unsigned char tchscr_adjust_lftp( unsigned short lcd_pos_x, unsigned short lcd_pos_y, unsigned short pen_val_x, unsigned short pen_val_y )
  536. {
  537. unsigned long  err2;
  538. unsigned long  rad2;
  541. err2 = (tchscr_pen.PanelDotX-lcd_pos_x)*(tchscr_pen.PanelDotX-lcd_pos_x) +
  542. (tchscr_pen.PanelDotY-lcd_pos_y)*(tchscr_pen.PanelDotY-lcd_pos_y);
  543. rad2 = TARGET_RAD*TARGET_RAD;
  544. if( err2 > rad2 )
  545. return 0;
  546. #ifdef _NEW_TOUCHPANEL_
  547. {
  549. tchscr_rectif.lftp_val_x = ( (pen_val_x*LCD_XSIZE/2) - (tchscr_rectif.cent_val_x*lcd_pos_x) )
  550. /(LCD_XSIZE/2-lcd_pos_x);
  551. tchscr_rectif.lftp_val_y = ( (pen_val_y*LCD_YSIZE/2) - (tchscr_rectif.cent_val_y*lcd_pos_y) )
  552. /(LCD_YSIZE/2-lcd_pos_y);
  553. }
  554. #else
  555. {
  556. tchscr_rectif.lftp_val_x = ( (pen_val_x*LCD_XSIZE/2) - (tchscr_rectif.cent_val_x*lcd_pos_x) )
  557. /(LCD_XSIZE/2-lcd_pos_x);
  558. tchscr_rectif.lftp_val_y = ( (pen_val_y*LCD_YSIZE/2) - (tchscr_rectif.cent_val_y*lcd_pos_y) )
  559. /(LCD_YSIZE/2-lcd_pos_y);
  560. }
  561. #endif
  562. /*
  563. tchscr_rectif.lftp_val_x = tchscr_rectif.cent_val_x-(LCD_XSIZE/2-0)*(tchscr_rectif.cent_val_x-pen_val_x) 
  564. /(LCD_XSIZE/2-lcd_pos_x);
  565. tchscr_rectif.lftp_val_y = tchscr_rectif.cent_val_y-(LCD_YSIZE/2-0)*(tchscr_rectif.cent_val_y-pen_val_y) 
  566. /(LCD_YSIZE/2-lcd_pos_y);
  567. */
  568. tchscr_rectif.lftp_crd_x= 0;
  569. tchscr_rectif.lftp_crd_y= 0;
  570. return 1;
  571. }
  573. unsigned char tchscr_adjust_rghtp( unsigned short lcd_pos_x, unsigned short lcd_pos_y, unsigned short pen_val_x, unsigned short pen_val_y )
  574. {
  575. unsigned long  err2;
  576. unsigned long  rad2;
  579. err2 = (tchscr_pen.PanelDotX-lcd_pos_x)*(tchscr_pen.PanelDotX-lcd_pos_x) +
  580. (tchscr_pen.PanelDotY-lcd_pos_y)*(tchscr_pen.PanelDotY-lcd_pos_y);
  581. rad2 = TARGET_RAD*TARGET_RAD;
  582. if( err2 > rad2 )
  583. return 0;
  584. else
  585. return 1;
  586. }
  588. unsigned char tchscr_adjust_lfbm( unsigned short lcd_pos_x, unsigned short lcd_pos_y, unsigned short pen_val_x, unsigned short pen_val_y )
  589. {
  590. unsigned long  err2;
  591. unsigned long  rad2;
  594. err2 = (tchscr_pen.PanelDotX-lcd_pos_x)*(tchscr_pen.PanelDotX-lcd_pos_x) +
  595. (tchscr_pen.PanelDotY-lcd_pos_y)*(tchscr_pen.PanelDotY-lcd_pos_y);
  596. rad2 = TARGET_RAD*TARGET_RAD;
  597. if( err2 > rad2 )
  598. return 0;
  599. else
  600. return 1;
  601. }
  603. unsigned char tchscr_adjust_rghbm( unsigned short lcd_pos_x, unsigned short lcd_pos_y, unsigned short pen_val_x, unsigned short pen_val_y )
  604. {
  605. unsigned long  err2;
  606. unsigned long  rad2;
  609. err2 = (tchscr_pen.PanelDotX-lcd_pos_x)*(tchscr_pen.PanelDotX-lcd_pos_x) +
  610. (tchscr_pen.PanelDotY-lcd_pos_y)*(tchscr_pen.PanelDotY-lcd_pos_y);
  611. rad2 = TARGET_RAD*TARGET_RAD;
  612. if( err2 > rad2 )
  613. return 0;
  614. #ifdef _NEW_TOUCHPANEL_
  615. {
  616. tchscr_rectif.rghbm_val_x = ( (pen_val_x*LCD_XSIZE/2) -(tchscr_rectif.cent_val_x*(LCD_XSIZE-lcd_pos_x)) )
  617. /(lcd_pos_x-LCD_XSIZE/2);
  618. tchscr_rectif.rghbm_val_y = ( (pen_val_y*LCD_YSIZE/2) -(tchscr_rectif.cent_val_y*(LCD_YSIZE-lcd_pos_y)) )
  619. /(lcd_pos_y-LCD_YSIZE/2);
  620. }
  621. #else
  622. {
  623. tchscr_rectif.rghbm_val_x = ( (pen_val_x*LCD_XSIZE/2) -(tchscr_rectif.cent_val_x*(LCD_XSIZE-lcd_pos_x)) )
  624. /(lcd_pos_x-LCD_XSIZE/2);
  625. tchscr_rectif.rghbm_val_y = ( (pen_val_y*LCD_YSIZE/2) -(tchscr_rectif.cent_val_y*(LCD_YSIZE-lcd_pos_y)) )
  626. /(lcd_pos_y-LCD_YSIZE/2);
  627. }
  628. #endif
  629. /*
  630. tchscr_rectif.rghbm_val_x = tchscr_rectif.cent_val_x+( (pen_val_x-tchscr_rectif.cent_val_x)*LCD_XSIZE/2 )
  631. /(lcd_pos_x-LCD_XSIZE/2);
  632. tchscr_rectif.rghbm_val_y = tchscr_rectif.cent_val_y+( (pen_val_y-tchscr_rectif.cent_val_y)*LCD_YSIZE/2 )
  633. /(lcd_pos_y-LCD_YSIZE/2);
  634. */
  635. tchscr_rectif.rghbm_crd_x= LCD_XSIZE;
  636. tchscr_rectif.rghbm_crd_y= LCD_YSIZE;
  637. return 1;
  638. }
  640. void tchscr_get_advalue( unsigned short * p_val_x, unsigned short * p_val_y )
  641. {
  642. int  min,max,sum=0,i;
  643. //*p_val_x = tchscr.PanelDotX;
  644. //*p_val_y = tchscr.PanelDotY;
  645. min=0xffff;
  646. max=0;
  647. for(i=0;i<PANRECLEN;i++)
  648. {
  649. sum+=penrectif[i].PanelDotX;
  650. if(penrectif[i].PanelDotX<min)
  651. min=penrectif[i].PanelDotX;
  652. if(penrectif[i].PanelDotX>max)
  653. max=penrectif[i].PanelDotX;
  654. }
  655. * p_val_x=(sum-min-max)/(PANRECLEN-2);
  656. min=0xffff;
  657. max=0;
  658. sum=0;
  659. for(i=0;i<PANRECLEN;i++)
  660. {
  661. sum+=penrectif[i].PanelDotY;
  662. if(penrectif[i].PanelDotY<min)
  663. min=penrectif[i].PanelDotY;
  664. if(penrectif[i].PanelDotY>max)
  665. max=penrectif[i].PanelDotY;
  666. }
  667. * p_val_y=(sum-min-max)/(PANRECLEN-2);
  669. }
  671. void tchscr_save_rectif( void )
  672. {
  673. /* _SYSINFO  temp_sysinfo;
  675. ReadSysInfo( (_SYSINFO *)&temp_sysinfo );
  676. memcpy( &temp_sysinfo.byPanelAdjust[0], (unsigned char*)&tchscr_rectif, sizeof(TCHSCR_RECTIF) );
  677. // sizeof(TCHSCR_RECTIF) should be <= 52bytes, now is 40 bytes
  678. temp_sysinfo.dwPanelSetFlag = 0x12345678;
  679. WriteSysInfo( (_SYSINFO *)&temp_sysinfo );*/
  680. }
  682. void GetAdjustmentAD(unsigned short *wTouchX, unsigned short *wTouchY)
  683. {
  684. tchscr_get_advalue( wTouchX, wTouchY );
  685. }
  687. unsigned char CalculateTouchCentre(unsigned short wLcdX, unsigned short wLcdY, unsigned short wTouchX, unsigned short wTouchY)
  688. {
  689. return tchscr_adjust_center( wLcdX, wLcdY, wTouchX, wTouchY );
  690. }
  692. unsigned char CalculateTouchLeftTop(unsigned short wLcdX, unsigned short wLcdY, unsigned short wTouchX, unsigned short wTouchY)
  693. {
  694. return tchscr_adjust_lftp( wLcdX, wLcdY, wTouchX, wTouchY );
  695. }
  697. unsigned char CalculateTouchRightTop(unsigned short wLcdX, unsigned short wLcdY, unsigned short wTouchX, unsigned short wTouchY)
  698. {
  699. return tchscr_adjust_rghtp( wLcdX, wLcdY, wTouchX, wTouchY );
  700. }
  702. unsigned char CalculateTouchLeftBottom( unsigned short wLcdX, unsigned short wLcdY, unsigned short wTouchX, unsigned short wTouchY )
  703. {
  704. return tchscr_adjust_lfbm( wLcdX, wLcdY, wTouchX, wTouchY );
  705. }
  707. unsigned char CalculateTouchRightBottom( unsigned short wLcdX, unsigned short wLcdY, unsigned short wTouchX, unsigned short wTouchY )
  708. {
  709. return tchscr_adjust_rghbm( wLcdX, wLcdY, wTouchX, wTouchY );
  710. }
  712. void BiosSavePenAdjustment(void)
  713. {
  714. tchscr_save_rectif();
  715. }
  717. void BorderAverage(void)
  718. {
  720. }
  722. enum_TCHSCR_AREA tchscr_recognize_area( void )
  723. {
  724. if( tchscr.PanelDotY<= tchscr_rectif.cent_val_y )
  725. {
  726. if( tchscr.PanelDotX<= tchscr_rectif.cent_val_x )
  727. return TCHSCR_AREA_A;
  728. else
  729. return TCHSCR_AREA_B;
  730. }
  731. else
  732. {
  733. if( tchscr.PanelDotX<= tchscr_rectif.cent_val_x )
  734. return TCHSCR_AREA_C;
  735. else
  736. return TCHSCR_AREA_D;
  737. }
  738. }
  740. void tchscr_calcu_pencoord( void )
  741. {
  742. enum_TCHSCR_AREA  area;
  744. area = tchscr_recognize_area();
  745. #ifndef _NEW_TOUCHPANEL_
  746. switch (area)
  747. {
  748. case TCHSCR_AREA_A:
  749. if(tchscr.PanelDotX>= tchscr_rectif.lftp_val_x)
  750. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.lftp_val_x)*(LCD_XSIZE/2)
  751. /(tchscr_rectif.cent_val_x-tchscr_rectif.lftp_val_x);
  752. else
  753. tchscr_pen.PanelDotX = 0;
  754. if(tchscr.PanelDotY>= tchscr_rectif.lftp_val_y)
  755. tchscr_pen.PanelDotY= (tchscr.PanelDotY-tchscr_rectif.lftp_val_y)*(LCD_YSIZE/2)
  756. /(tchscr_rectif.cent_val_y-tchscr_rectif.lftp_val_y);
  757. else
  758. tchscr_pen.PanelDotY = 0;
  759. break;
  760. case TCHSCR_AREA_B:
  761. if( tchscr.PanelDotX <= tchscr_rectif.rghbm_val_x )
  762. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  763. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  764. else
  765. tchscr_pen.PanelDotX = LCD_XSIZE-1;
  766. if( tchscr.PanelDotY >= tchscr_rectif.lftp_val_y )
  767. tchscr_pen.PanelDotY = (tchscr.PanelDotY-tchscr_rectif.lftp_val_y)*(LCD_YSIZE/2)
  768. /(tchscr_rectif.cent_val_y-tchscr_rectif.lftp_val_y);
  769. else
  770. tchscr_pen.PanelDotY = 0;
  771. break;
  772. case TCHSCR_AREA_C:
  773. if( tchscr.PanelDotX >= tchscr_rectif.lftp_val_x )
  774. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.lftp_val_x)*(LCD_XSIZE/2)
  775. /(tchscr_rectif.cent_val_x-tchscr_rectif.lftp_val_x);
  776. else
  777. tchscr_pen.PanelDotX = 0;
  778. if( tchscr.PanelDotY <= tchscr_rectif.rghbm_val_y )
  779. tchscr_pen.PanelDotY = (tchscr.PanelDotY-tchscr_rectif.cent_val_y)*(LCD_YSIZE/2)
  780. /(tchscr_rectif.rghbm_val_y-tchscr_rectif.cent_val_y)+(LCD_YSIZE/2);
  781. else
  782. tchscr_pen.PanelDotY = LCD_YSIZE-1;
  783. break;
  784. case TCHSCR_AREA_D:
  785. if( tchscr.PanelDotX <= tchscr_rectif.rghbm_val_x )
  786. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  787. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  788. else
  789. tchscr_pen.PanelDotY = LCD_XSIZE-1;
  790. if( tchscr.PanelDotY <= tchscr_rectif.rghbm_val_y )
  791. tchscr_pen.PanelDotY = (tchscr.PanelDotY-tchscr_rectif.cent_val_y)*(LCD_YSIZE/2)
  792. /(tchscr_rectif.rghbm_val_y-tchscr_rectif.cent_val_y)+(LCD_YSIZE/2);
  793. else
  794. tchscr_pen.PanelDotY = LCD_YSIZE-1;
  795. break;
  796. default:
  797. ;
  798. }
  799. #else
  801. switch (area)
  802. {
  803. case TCHSCR_AREA_C:
  804. if(tchscr.PanelDotX>= tchscr_rectif.lftp_val_x)
  805. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.lftp_val_x)*(LCD_XSIZE/2)
  806. /(tchscr_rectif.cent_val_x-tchscr_rectif.lftp_val_x);
  807. else
  808. tchscr_pen.PanelDotX = 0;
  809. if(tchscr.PanelDotY<= tchscr_rectif.lftp_val_y)
  810. tchscr_pen.PanelDotY= (tchscr_rectif.lftp_val_y-tchscr.PanelDotY)*(LCD_YSIZE/2)
  811. /(tchscr_rectif.lftp_val_y-tchscr_rectif.cent_val_y);
  812. else
  813. tchscr_pen.PanelDotY = 0;
  814. break;
  815. case TCHSCR_AREA_D:
  816. if(tchscr.PanelDotX<= tchscr_rectif.rghbm_val_x)
  817. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  818. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  819. else
  820. tchscr_pen.PanelDotX = LCD_XSIZE-1;
  821. if(tchscr.PanelDotY<= tchscr_rectif.lftp_val_y)
  822. tchscr_pen.PanelDotY= (tchscr_rectif.lftp_val_y-tchscr.PanelDotY)*(LCD_YSIZE/2)
  823. /(tchscr_rectif.lftp_val_y-tchscr_rectif.cent_val_y);
  824. else
  825. tchscr_pen.PanelDotY = 0;
  826. break;
  827. case TCHSCR_AREA_A:
  828. if(tchscr.PanelDotX>= tchscr_rectif.lftp_val_x)
  829. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.lftp_val_x)*(LCD_XSIZE/2)
  830. /(tchscr_rectif.cent_val_x-tchscr_rectif.lftp_val_x);
  831. else
  832. tchscr_pen.PanelDotX = 0;
  833. if( tchscr.PanelDotY >= tchscr_rectif.rghbm_val_y )
  834. tchscr_pen.PanelDotY = (tchscr_rectif.cent_val_y-tchscr.PanelDotY)*(LCD_YSIZE/2)
  835. /(tchscr_rectif.cent_val_y-tchscr_rectif.rghbm_val_y)+(LCD_YSIZE/2);
  836. else
  837. tchscr_pen.PanelDotY = LCD_YSIZE-1;
  838. break;
  839. case TCHSCR_AREA_B:
  840. if(tchscr.PanelDotX<= tchscr_rectif.rghbm_val_x)
  841. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  842. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  843. else
  844. tchscr_pen.PanelDotX = LCD_XSIZE-1;
  845. if( tchscr.PanelDotY >= tchscr_rectif.rghbm_val_y )
  846. tchscr_pen.PanelDotY = (tchscr_rectif.cent_val_y-tchscr.PanelDotY)*(LCD_YSIZE/2)
  847. /(tchscr_rectif.cent_val_y-tchscr_rectif.rghbm_val_y)+(LCD_YSIZE/2);
  848. else
  849. tchscr_pen.PanelDotY = LCD_YSIZE-1;
  850. break;
  851. default:
  852. break;
  853. }
  855. #if 0
  856. switch (area)
  857. {
  858. case TCHSCR_AREA_A:
  859. if(tchscr.PanelDotX>= tchscr_rectif.rghbm_val_x)
  860. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  861. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  862. else
  863. tchscr_pen.PanelDotX = PEN_ERR;
  864. if(tchscr.PanelDotY>= tchscr_rectif.lftp_val_y)
  865. tchscr_pen.PanelDotY= (tchscr.PanelDotY-tchscr_rectif.lftp_val_y)*(LCD_YSIZE/2)
  866. /(tchscr_rectif.cent_val_y-tchscr_rectif.lftp_val_y);
  867. else
  868. tchscr_pen.PanelDotY = PEN_ERR;
  869. break;
  870. case TCHSCR_AREA_B:
  871. if(tchscr.PanelDotX<= tchscr_rectif.lftp_val_x)
  872. tchscr_pen.PanelDotX = (tchscr_rectif.lftp_val_x-tchscr.PanelDotX)*(LCD_XSIZE/2)
  873. /(tchscr_rectif.lftp_val_x-tchscr_rectif.cent_val_x);
  874. else
  875. tchscr_pen.PanelDotX = PEN_ERR;
  876. if(tchscr.PanelDotY>= tchscr_rectif.lftp_val_y)
  877. tchscr_pen.PanelDotY= (tchscr.PanelDotY-tchscr_rectif.lftp_val_y)*(LCD_YSIZE/2)
  878. /(tchscr_rectif.cent_val_y-tchscr_rectif.lftp_val_y);
  879. else
  880. tchscr_pen.PanelDotY = PEN_ERR;
  881. break;
  882. case TCHSCR_AREA_C:
  883. if(tchscr.PanelDotX>= tchscr_rectif.rghbm_val_x)
  884. tchscr_pen.PanelDotX = (tchscr.PanelDotX-tchscr_rectif.cent_val_x)*(LCD_XSIZE/2)
  885. /(tchscr_rectif.rghbm_val_x-tchscr_rectif.cent_val_x)+(LCD_XSIZE/2);
  886. else
  887. tchscr_pen.PanelDotX = PEN_ERR;
  888. if( tchscr.PanelDotY <= tchscr_rectif.rghbm_val_y )
  889. tchscr_pen.PanelDotY = (tchscr.PanelDotY-tchscr_rectif.cent_val_y)*(LCD_YSIZE/2)
  890. /(tchscr_rectif.rghbm_val_y-tchscr_rectif.cent_val_y)+(LCD_YSIZE/2);
  891. else
  892. tchscr_pen.PanelDotY = PEN_ERR;
  893. break;
  894. case TCHSCR_AREA_D:
  895. if(tchscr.PanelDotX<= tchscr_rectif.lftp_val_x)
  896. tchscr_pen.PanelDotX = (tchscr_rectif.lftp_val_x-tchscr.PanelDotX)*(LCD_XSIZE/2)
  897. /(tchscr_rectif.lftp_val_x-tchscr_rectif.cent_val_x);
  898. else
  899. tchscr_pen.PanelDotX = PEN_ERR;
  900. if( tchscr.PanelDotY <= tchscr_rectif.rghbm_val_y )
  901. tchscr_pen.PanelDotY = (tchscr.PanelDotY-tchscr_rectif.cent_val_y)*(LCD_YSIZE/2)
  902. /(tchscr_rectif.rghbm_val_y-tchscr_rectif.cent_val_y)+(LCD_YSIZE/2);
  903. else
  904. tchscr_pen.PanelDotY = PEN_ERR;
  905. break;
  906. default:
  907. break;
  908. }
  909. #endif
  910. #endif
  912. }
  914. void tsGetDefParam(void * pTSAdjustParam)
  915. {
  916. TCHSCR_RECTIF *tchscr_rec=(TCHSCR_RECTIF *)pTSAdjustParam;
  917. memset(tchscr_rec,0,sizeof(TCHSCR_RECTIF));
  918. #ifndef _NEW_TOUCHPANEL_
  920. #if 0 //this is DVT2 default
  921. tchscr_rec->cent_val_x=518;
  922. tchscr_rec->cent_val_y=518;
  923. tchscr_rec->lftp_val_x=138;//158 rghtp_val_x
  924. tchscr_rec->lftp_val_y=138;//834 rghtp_val_y
  925. tchscr_rec->rghbm_val_x=898;//858 lftbm_val_x
  926. tchscr_rec->rghbm_val_y=898;//209 lftbm_val_y
  927. #endif
  928. // for pvt below, 20071029 by TH
  929. tchscr_rec->cent_val_x=510;
  930. tchscr_rec->cent_val_y=510;
  931. tchscr_rec->lftp_val_x=146;
  932. tchscr_rec->lftp_val_y=106;
  933. tchscr_rec->rghbm_val_x=883;
  934. tchscr_rec->rghbm_val_y=922;
  936. tchscr_rec->cent_crd_x=LCD_XSIZE/2;
  937. tchscr_rec->cent_crd_y=LCD_YSIZE/2;
  938. tchscr_rec->rghbm_crd_x=LCD_XSIZE;
  939. tchscr_rec->rghbm_crd_y=LCD_YSIZE;
  942. #else
  943. #ifdef _IACN_MA8_PROJ_
  944. tchscr_rec->cent_val_x=499;//532;
  945. tchscr_rec->cent_val_y=514;//507;
  946. tchscr_rec->lftp_val_x=153;//155;//158 rghtp_val_x
  947. tchscr_rec->lftp_val_y=937;//950;//834 rghtp_val_y
  948. tchscr_rec->rghbm_val_x=838;//890;//858 lftbm_val_x
  949. tchscr_rec->rghbm_val_y=83;//71;//209 lftbm_val_y
  951. tchscr_rec->cent_crd_x=LCD_XSIZE/2;
  952. tchscr_rec->cent_crd_y=LCD_YSIZE/2;
  953. tchscr_rec->rghbm_crd_x=LCD_XSIZE;
  954. tchscr_rec->rghbm_crd_y=LCD_YSIZE;
  956. #endif
  957. #endif
  959. }
  961. void tsSetUserParam(void * pTSAdjustParam)
  962. {
  963. TCHSCR_RECTIF *tchscr_rec=(TCHSCR_RECTIF *)pTSAdjustParam;
  964. tchscr_rectif.cent_val_x=tchscr_rec->cent_val_x;
  965. tchscr_rectif.cent_val_y=tchscr_rec->cent_val_y;
  966. tchscr_rectif.lftp_val_x=tchscr_rec->lftp_val_x;
  967. tchscr_rectif.lftp_val_y=tchscr_rec->lftp_val_y;
  968. tchscr_rectif.rghbm_val_x=tchscr_rec->rghbm_val_x;
  969. tchscr_rectif.rghbm_val_y=tchscr_rec->rghbm_val_y;
  971. tchscr_rectif.cent_crd_x=tchscr_rec->cent_crd_x;
  972. tchscr_rectif.cent_crd_y=tchscr_rec->cent_crd_y;
  973. tchscr_rectif.rghbm_crd_x=tchscr_rec->rghbm_crd_x;
  974. tchscr_rectif.rghbm_crd_y=tchscr_rec->rghbm_crd_y;
  975. }
  976. void tsGetCurParam(void * pTSAdjustParam)
  977. {
  978. memcpy( pTSAdjustParam, &tchscr_rectif, sizeof(tchscr_rectif));
  979. }
  982. int  tsIsValidParam(void * pTSAdjustParam)
  983. {
  984. #if 0
  985. unsigned long  err2;
  986. unsigned long  rad2;
  987. TCHSCR_RECTIF  tchdef;
  988. TCHSCR_RECTIF *tchdef_rec=&tchdef;
  989. TCHSCR_RECTIF *tchscr_rec=(TCHSCR_RECTIF *)pTSAdjustParam;
  990. tsGetDefParam(tchdef_rec);
  991. rad2 = 90*90;
  992. if((tchscr_rec->cent_crd_x!=tchdef_rec->cent_crd_x)||(tchscr_rec->cent_crd_y!=tchdef_rec->cent_crd_y)||(tchscr_rec->cent_crd_x!=tchdef_rec->cent_crd_x)||(tchscr_rec->rghbm_crd_x!=tchdef_rec->rghbm_crd_x)||(tchscr_rec->rghbm_crd_y!=tchdef_rec->rghbm_crd_y))
  993. return 0;
  994. err2 = (tchscr_rec->cent_val_x-tchdef_rec->cent_val_x)*(tchscr_rec->cent_val_x-tchdef_rec->cent_val_x) +
  995. (tchscr_rec->cent_val_y-tchdef_rec->cent_val_y)*(tchscr_rec->cent_val_y-tchdef_rec->cent_val_y);
  996. if( err2 > rad2 )
  997. return 0;
  998. err2 = (tchscr_rec->lftp_val_x-tchdef_rec->lftp_val_x)*(tchscr_rec->lftp_val_x-tchdef_rec->lftp_val_x) +
  999. (tchscr_rec->lftp_val_y-tchdef_rec->lftp_val_y)*(tchscr_rec->lftp_val_y-tchdef_rec->lftp_val_y);
  1000. if( err2 > rad2 )
  1001. return 0;
  1002. err2 = (tchscr_rec->rghbm_val_x-tchdef_rec->rghbm_val_x)*(tchscr_rec->rghbm_val_x-tchdef_rec->rghbm_val_x) +
  1003. (tchscr_rec->rghbm_val_y-tchdef_rec->rghbm_val_y)*(tchscr_rec->rghbm_val_y-tchdef_rec->rghbm_val_y);
  1004. if( err2 > rad2 )
  1005. return 0;
  1006. #endif
  1007. return 1;
  1009. }
  1011. unsigned int tsIsNewVersion(void)
  1012. {
  1013. #ifdef       _NEW_TOUCHPANEL_
  1014. return 1;
  1015. #else
  1016. return 0;
  1017. #endif
  1018. }