Touch.cpp

00001 // Code based on Carlos E. Vidales tutorial : How To Calibrate Touch Screens
00002 // http://www.embedded.com/design/configurable-systems/4023968/How-To-Calibrate-Touch-Screens
00003 
00004 #include "Touch.h"
00005 #include "mbed.h"
00006 #include "Arial12x12.h"
00007 
00008 // (To be modified) C code below works on KEIL compiler but NOT on LPCXpresso/mbed 
00009 //Matrix matrix ;
00010 //Coordinate  display ;
00011 
00012 Coordinate ScreenSample[3] =   {
00013         { 45, 45 },
00014         { 45, 270},
00015         { 190,190}
00016 } ;
00017 Coordinate DisplaySample[3] =   {
00018         { 45, 45 },
00019         { 45, 270},
00020         { 190,190}
00021 } ;
00022 
00023 #define THRESHOLD 2
00024 // **********************************************************************
00025 
00026 TouchScreenADS7843::TouchScreenADS7843(PinName tp_mosi,PinName tp_miso,PinName tp_sclk,PinName tp_cs,PinName tp_irq,PinName mosi, PinName miso, PinName sclk, PinName cs, PinName reset,const char* name)
00027         : SPI_TFT(mosi,miso,sclk,cs,reset,name), _tp_spi(tp_mosi, tp_miso, tp_sclk), _tp_cs(tp_cs), _tp_irq(tp_irq){}
00028 // **********************************************************************
00029 void TouchScreenADS7843::TP_Init(void)
00030 {
00031     _tp_cs=1;
00032     _tp_spi.frequency(500000);
00033        _tp_spi.format(8,0);                    // 8 bit spi mode 3
00034 }
00035 
00036 int TouchScreenADS7843::Read_XY(unsigned char XY)
00037 {
00038     unsigned char msb, lsb;
00039     unsigned int Temp;
00040 
00041     Temp=0;
00042     _tp_cs=0;
00043     wait_us(SPI_RD_DELAY);
00044     _tp_spi.write(XY);
00045     wait_us(SPI_RD_DELAY);
00046     msb = _tp_spi.write(0x00); // msb
00047     wait_us(SPI_RD_DELAY);
00048     lsb = _tp_spi.write(0x00); // lsb
00049     _tp_cs=1;
00050     Temp = ((msb <<8 ) | lsb);
00051     Temp >>= 3;
00052     Temp &= 0xfff;
00053     Temp /= 4;        // Scaling : return value range must be between 0 and 1024
00054 //    Temp = (((msb & 0x7f) <<8) | lsb) >> 3;        // 12 bit
00055     return(Temp);
00056 }
00057 
00058 
00059 void TouchScreenADS7843::TP_GetAdXY(int *x,int *y)
00060 {
00061     int adx,ady;
00062     adx = Read_XY(CHX);
00063     wait_us(1);
00064     ady = Read_XY(CHY);
00065     *x = adx;
00066     *y = ady;
00067 }
00068 
00069 void TouchScreenADS7843::TP_DrawPoint(unsigned int Xpos,unsigned int Ypos, unsigned int color)
00070 {
00071     wr_reg(0x03, 0x1030);
00072     WindowMax();
00073     pixel(Xpos,Ypos,color);
00074     pixel(Xpos+1,Ypos,color);
00075     pixel(Xpos,Ypos+1,color);
00076     pixel(Xpos+1,Ypos+1,color);
00077 }
00078 
00079 void TouchScreenADS7843::DrawCross(unsigned int Xpos,unsigned int Ypos)
00080 {
00081     line(Xpos-15,Ypos,Xpos-2,Ypos,White);
00082     line(Xpos+2,Ypos,Xpos+15,Ypos,White);
00083     line(Xpos,Ypos-15,Xpos,Ypos-2,White);
00084     line(Xpos,Ypos+2,Xpos,Ypos+15,White);
00085 
00086     line(Xpos-15,Ypos+15,Xpos-7,Ypos+15,DarkGrey);
00087     line(Xpos-15,Ypos+7,Xpos-15,Ypos+15,DarkGrey);
00088 
00089     line(Xpos-15,Ypos-15,Xpos-7,Ypos-15,DarkGrey);
00090     line(Xpos-15,Ypos-7,Xpos-15,Ypos-15,DarkGrey);
00091 
00092     line(Xpos+7,Ypos+15,Xpos+15,Ypos+15,DarkGrey);
00093     line(Xpos+15,Ypos+7,Xpos+15,Ypos+15,DarkGrey);
00094 
00095     line(Xpos+7,Ypos-15,Xpos+15,Ypos-15,DarkGrey);
00096     line(Xpos+15,Ypos-15,Xpos+15,Ypos-7,DarkGrey);
00097 }
00098 
00099 unsigned char TouchScreenADS7843::Read_Ads7846(Coordinate * screenPtr)
00100 {
00101 //    static Coordinate  screen;
00102     int m0,m1,m2,TP_X[1],TP_Y[1],temp[3];
00103     uint8_t count=0;
00104     int buffer[2][9]={{0},{0}};
00105     do
00106     {
00107         TP_GetAdXY(TP_X,TP_Y);
00108         buffer[0][count]=TP_X[0];
00109         buffer[1][count]=TP_Y[0];
00110         count++;
00111     }
00112     while(!_tp_irq && (count < 9));
00113     if(count==9)
00114     {
00115         temp[0]=(buffer[0][0]+buffer[0][1]+buffer[0][2])/3;
00116         temp[1]=(buffer[0][3]+buffer[0][4]+buffer[0][5])/3;
00117         temp[2]=(buffer[0][6]+buffer[0][7]+buffer[0][8])/3;
00118         m0=temp[0]-temp[1];
00119         m1=temp[1]-temp[2];
00120         m2=temp[2]-temp[0];
00121         m0=m0>0?m0:(-m0);
00122         m1=m1>0?m1:(-m1);
00123         m2=m2>0?m2:(-m2);
00124         if( (m0>THRESHOLD)  &&  (m1>THRESHOLD)  &&  (m2>THRESHOLD) ) return 0;
00125         if(m0<m1)
00126         {
00127             if(m2<m0)
00128                 screenPtr->x=(temp[0]+temp[2])/2;
00129             else
00130                 screenPtr->x=(temp[0]+temp[1])/2;
00131         }
00132         else if(m2<m1)
00133             screenPtr->x=(temp[0]+temp[2])/2;
00134         else
00135             screenPtr->x=(temp[1]+temp[2])/2;
00136 
00137         temp[0]=(buffer[1][0]+buffer[1][1]+buffer[1][2])/3;
00138         temp[1]=(buffer[1][3]+buffer[1][4]+buffer[1][5])/3;
00139         temp[2]=(buffer[1][6]+buffer[1][7]+buffer[1][8])/3;
00140         m0=temp[0]-temp[1];
00141         m1=temp[1]-temp[2];
00142         m2=temp[2]-temp[0];
00143         m0=m0>0?m0:(-m0);
00144         m1=m1>0?m1:(-m1);
00145         m2=m2>0?m2:(-m2);
00146         if( (m0>THRESHOLD)  &&  (m1>THRESHOLD)  &&  (m2>THRESHOLD) ) return 0;
00147 
00148         if(m0<m1)
00149         {
00150             if(m2<m0)
00151                 screenPtr->y=(temp[0]+temp[2])/2;
00152             else
00153                 screenPtr->y=(temp[0]+temp[1])/2;
00154         }
00155         else if(m2<m1)
00156             screenPtr->y=(temp[0]+temp[2])/2;
00157         else
00158             screenPtr->y=(temp[1]+temp[2])/2;
00159         return 1;
00160     }
00161     return 0;
00162 }
00163 
00164 uint8_t TouchScreenADS7843::setCalibrationMatrix( Coordinate * displayPtr,
00165         Coordinate * screenPtr,
00166         Matrix * matrixPtr)
00167 {
00168     uint8_t retTHRESHOLD = 0 ;
00169     // K = (Xs0 - Xs2)*(Ys1 - Ys2) - (Xs1 - Xs2)*(Ys0 - Ys2)
00170     matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
00171                          ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
00172     if( matrixPtr->Divider == 0 )
00173     {
00174         retTHRESHOLD = 1;
00175     }
00176     else
00177     {
00178         //                 (Xd0 - Xd2)*(Ys1 - Ys2) - (Xd1 - Xd2)*(Ys0 - Ys2)
00179         //            A = ---------------------------------------------------
00180         //                                   K
00181         matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
00182                           ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
00183         //                 (Xs0 - Xs2)*(Xd1 - Xd2) - (Xd0 - Xd2)*(Xs1 - Xs2)
00184         //            B = ---------------------------------------------------
00185         //                                   K
00186         matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
00187                         ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
00188         //                 Ys0*(Xs2*Xd1 - Xs1*Xd2) + Ys1*(Xs0*Xd2 - Xs2*Xd0) + Ys2*(Xs1*Xd0 - Xs0*Xd1)
00189         //            C = ----------------------------------------------------------------------------
00190         //                                   K
00191         matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
00192                         (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
00193                         (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
00194         //                 (Yd0 - Yd2)*(Ys1 - Ys2) - (Yd1 - Yd2)*(Ys0 - Ys2)
00195         //            D = ---------------------------------------------------
00196         //                                   K
00197         matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
00198                         ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
00199         //                 (Xs0 - Xs2)*(Yd1 - Yd2) - (Yd0 - Yd2)*(Xs1 - Xs2)
00200         //            E = ---------------------------------------------------
00201         //                                   K
00202         matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
00203                         ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
00204         //                 Ys0*(Xs2*Yd1 - Xs1*Yd2) + Ys1*(Xs0*Yd2 - Xs2*Yd0) + Ys2*(Xs1*Yd0 - Xs0*Yd1)
00205         //            F = ----------------------------------------------------------------------------
00206         //                                   K
00207         matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
00208                         (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
00209                         (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
00210     }
00211     return( retTHRESHOLD ) ;
00212 }
00213 
00214 uint8_t TouchScreenADS7843::getDisplayPoint(Coordinate *displayPtr,
00215         Coordinate *screenPtr,
00216         Matrix *matrixPtr )
00217 {
00218     uint8_t retTHRESHOLD = 0 ;
00219 
00220     if( matrixPtr->Divider != 0 )
00221     {
00222         // XD = AX+BY+C
00223         displayPtr->x = ( (matrixPtr->An * screenPtr->x) +
00224                           (matrixPtr->Bn * screenPtr->y) +
00225                            matrixPtr->Cn
00226                          ) / matrixPtr->Divider ;
00227         // YD = DX+EY+F
00228         displayPtr->y = ( (matrixPtr->Dn * screenPtr->x) +
00229                           (matrixPtr->En * screenPtr->y) +
00230                            matrixPtr->Fn
00231                          ) / matrixPtr->Divider ;
00232     }
00233     else
00234     {
00235         retTHRESHOLD = 1;
00236     }
00237     return(retTHRESHOLD);
00238 }
00239 
00240 void TouchScreenADS7843::TouchPanel_Calibrate(Matrix *matrixPtr)
00241 {
00242     uint8_t i;
00243     Coordinate screen_cal;
00244     setCalibrationMatrix( &DisplaySample[0],&ScreenSample[0],matrixPtr ) ;
00245     set_font((unsigned char*) Arial12x12);
00246     for(i=0;i<3;i++)
00247     {
00248         cls();
00249         locate(10,10);
00250         printf("Touch crosshair to calibrate");
00251         wait_ms(500);
00252         DrawCross(DisplaySample[i].x,DisplaySample[i].y);
00253         do {} while (!Read_Ads7846(&screen_cal));
00254         ScreenSample[i].x= screen_cal.x; ScreenSample[i].y= screen_cal.y;
00255     }
00256     setCalibrationMatrix( &DisplaySample[0],&ScreenSample[0],matrixPtr ) ;
00257     cls();
00258 }
00259