This is the final version of Mini Gateway for Automation and Security desgined for Renesas GR Peach Design Contest

Dependencies:   GR-PEACH_video GraphicsFramework HTTPServer R_BSP mbed-rpc mbed-rtos Socket lwip-eth lwip-sys lwip FATFileSystem

Fork of mbed-os-example-mbed5-blinky by mbed-os-examples

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers Touch.cpp Source File

Touch.cpp

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