stm32f769i_discovery_ts.c

00001 /**
00002   ******************************************************************************
00003   * @file    stm32f769i_discovery_ts.c
00004   * @author  MCD Application Team
00005   * @brief   This file provides a set of functions needed to manage the Touch
00006   *          Screen on STM32F769I-DISCOVERY discovery board.
00007   ******************************************************************************
00008   * @attention
00009   *
00010   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
00011   *
00012   * Redistribution and use in source and binary forms, with or without modification,
00013   * are permitted provided that the following conditions are met:
00014   *   1. Redistributions of source code must retain the above copyright notice,
00015   *      this list of conditions and the following disclaimer.
00016   *   2. Redistributions in binary form must reproduce the above copyright notice,
00017   *      this list of conditions and the following disclaimer in the documentation
00018   *      and/or other materials provided with the distribution.
00019   *   3. Neither the name of STMicroelectronics nor the names of its contributors
00020   *      may be used to endorse or promote products derived from this software
00021   *      without specific prior written permission.
00022   *
00023   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00024   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00025   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00026   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00027   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00028   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00029   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00030   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00031   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00032   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00033   *
00034   ******************************************************************************
00035   */
00036 
00037 /* File Info : -----------------------------------------------------------------
00038                                    User NOTES
00039 1. How To use this driver:
00040 --------------------------
00041    - This driver is used to drive the touch screen module of the STM32F769I-DISCOVERY
00042      discoveryuation board on the K.O.D Optica Technology 480x800 TFT-LCD mounted on
00043      MB1166 daughter board. The touch screen driver IC inside the K.O.D module KM-040TMP-02
00044      is a FT6206 by Focal Tech.
00045 
00046 2. Driver description:
00047 ---------------------
00048   + Initialization steps:
00049      o Initialize the TS module using the BSP_TS_Init() function. This
00050        function includes the MSP layer hardware resources initialization and the
00051        communication layer configuration to start the TS use. The LCD size properties
00052        (x and y) are passed as parameters.
00053      o If TS interrupt mode is desired, you must configure the TS interrupt mode
00054        by calling the function BSP_TS_ITConfig(). The TS interrupt mode is generated
00055        as an external interrupt whenever a touch is detected.
00056        The interrupt mode internally uses the IO functionalities driver driven by
00057        the IO expander, to configure the IT line.
00058 
00059   + Touch screen use
00060      o The touch screen state is captured whenever the function BSP_TS_GetState() is
00061        used. This function returns information about the last LCD touch occurred
00062        in the TS_StateTypeDef structure.
00063      o The IT is handled using the corresponding external interrupt IRQ handler,
00064        the user IT callback treatment is implemented on the same external interrupt
00065        callback.
00066 
00067 ------------------------------------------------------------------------------*/
00068 
00069 /* Dependencies
00070 - stm32f769i_eval_lcd.c
00071 - ft6x06.c
00072 EndDependencies */
00073 
00074 /* Includes ------------------------------------------------------------------*/
00075 #include "stm32f769i_discovery.h"
00076 #include "stm32f769i_discovery_ts.h"
00077 
00078 /** @addtogroup BSP
00079   * @{
00080   */
00081 
00082 /** @addtogroup STM32F769I_DISCOVERY
00083   * @{
00084   */
00085 
00086 /** @defgroup STM32F769I_DISCOVERY_TS STM32F769I_DISCOVERY TS
00087   * @{
00088   */
00089 
00090 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Types_Definitions TS Private Types Definitions
00091   * @{
00092   */
00093 /**
00094   * @}
00095   */
00096 
00097 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Defines TS Private Types Defines
00098   * @{
00099   */
00100 /**
00101   * @}
00102   */
00103 
00104 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Macros TS Private Macros
00105   * @{
00106   */
00107 /**
00108   * @}
00109   */
00110 
00111 /** @defgroup STM32F769I_DISCOVERY_TS_Imported_Variables TS Imported Variables
00112   * @{
00113   */
00114   /**
00115     * @}
00116     */
00117 
00118 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Variables TS Private Variables
00119   * @{
00120   */
00121 static TS_DrvTypeDef *ts_driver;
00122 static uint8_t  ts_orientation;
00123 uint8_t  I2C_Address = 0;
00124 
00125 /* Table for touchscreen event information display on LCD : table indexed on enum @ref TS_TouchEventTypeDef information */
00126 char * ts_event_string_tab[TOUCH_EVENT_NB_MAX] = { "None",
00127                                                    "Press down",
00128                                                    "Lift up",
00129                                                    "Contact"
00130                                                   };
00131 
00132 /* Table for touchscreen gesture Id information display on LCD : table indexed on enum @ref TS_GestureIdTypeDef information */
00133 char * ts_gesture_id_string_tab[GEST_ID_NB_MAX] = { "None",
00134                                                     "Move Up",
00135                                                     "Move Right",
00136                                                     "Move Down",
00137                                                     "Move Left",
00138                                                     "Zoom In",
00139                                                     "Zoom Out"
00140                                                   };
00141 
00142 /**
00143   * @}
00144   */
00145 
00146 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Function_Prototypes TS Private Function Prototypes
00147   * @{
00148   */
00149 
00150 /**
00151   * @}
00152   */
00153 
00154 /** @defgroup STM32F769I_DISCOVERY_TS_Public_Functions TS Public Functions
00155   * @{
00156   */
00157 
00158 /**
00159   * @brief  Initializes and configures the touch screen functionalities and
00160   *         configures all necessary hardware resources (GPIOs, I2C, clocks..).
00161   * @param  ts_SizeX : Maximum X size of the TS area on LCD
00162   * @param  ts_SizeY : Maximum Y size of the TS area on LCD
00163   * @retval TS_OK if all initializations are OK. Other value if error.
00164   */
00165 uint8_t BSP_TS_Init(uint16_t ts_SizeX, uint16_t ts_SizeY)
00166 {
00167   uint8_t ts_status = TS_OK;
00168   uint8_t ts_id1, ts_id2 = 0;
00169   /* Note : I2C_Address is un-initialized here, but is not used at all in init function */
00170   /* but the prototype of Init() is like that in template and should be respected       */
00171 
00172   /* Initialize the communication channel to sensor (I2C) if necessary */
00173   /* that is initialization is done only once after a power up         */
00174   ft6x06_ts_drv.Init(I2C_Address);
00175 
00176   ts_id1 = ft6x06_ts_drv.ReadID(TS_I2C_ADDRESS);
00177   if(ts_id1 != FT6206_ID_VALUE)
00178   {
00179     ts_id2 = ft6x06_ts_drv.ReadID(TS_I2C_ADDRESS_A02);
00180     I2C_Address    = TS_I2C_ADDRESS_A02;    
00181   }
00182   else
00183   {
00184     I2C_Address    = TS_I2C_ADDRESS;    
00185   }
00186   
00187   /* Scan FT6xx6 TouchScreen IC controller ID register by I2C Read       */
00188   /* Verify this is a FT6206 or FT6336G, otherwise this is an error case */
00189   if((ts_id1 == FT6206_ID_VALUE) || (ts_id2 == FT6206_ID_VALUE))
00190   {
00191     /* Found FT6206 : Initialize the TS driver structure */
00192     ts_driver = &ft6x06_ts_drv;
00193 
00194     /* Get LCD chosen orientation */
00195     if(ts_SizeX < ts_SizeY)
00196     {
00197       ts_orientation = TS_SWAP_NONE;                
00198     }
00199     else
00200     {
00201       ts_orientation = TS_SWAP_XY | TS_SWAP_Y;                 
00202     }
00203 
00204     if(ts_status == TS_OK)
00205     {
00206       /* Software reset the TouchScreen */
00207       ts_driver->Reset(I2C_Address);
00208 
00209       /* Calibrate, Configure and Start the TouchScreen driver */
00210       ts_driver->Start(I2C_Address);
00211 
00212     } /* of if(ts_status == TS_OK) */
00213   }
00214   else
00215   {
00216     ts_status = TS_DEVICE_NOT_FOUND;
00217   }
00218 
00219   return (ts_status);
00220 }
00221 
00222 /**
00223   * @brief  Configures and enables the touch screen interrupts.
00224   * @retval TS_OK if all initializations are OK. Other value if error.
00225   */
00226 uint8_t BSP_TS_ITConfig(void)
00227 {
00228   uint8_t ts_status = TS_OK;
00229   GPIO_InitTypeDef gpio_init_structure;
00230 
00231   /* Msp Init of GPIO used for TS_INT pin coming from TouchScreen driver IC FT6x06 */
00232   /* When touchscreen is operated in interrupt mode */
00233   BSP_TS_INT_MspInit();
00234 
00235   /* Configure Interrupt mode for TS_INT pin falling edge : when a new touch is available */
00236   /* TS_INT pin is active on low level on new touch available */
00237   gpio_init_structure.Pin = TS_INT_PIN;
00238   gpio_init_structure.Pull = GPIO_PULLUP;
00239   gpio_init_structure.Speed = GPIO_SPEED_FAST;
00240   gpio_init_structure.Mode = GPIO_MODE_IT_FALLING;
00241   HAL_GPIO_Init(TS_INT_GPIO_PORT, &gpio_init_structure);
00242 
00243   /* Enable and set the TS_INT EXTI Interrupt to an intermediate priority */
00244   HAL_NVIC_SetPriority((IRQn_Type)(TS_INT_EXTI_IRQn), 0x0F, 0x00);
00245   HAL_NVIC_EnableIRQ((IRQn_Type)(TS_INT_EXTI_IRQn));
00246 
00247   /* Enable the TS in interrupt mode */
00248   /* In that case the INT output of FT6206 when new touch is available */
00249   /* is active on low level and directed on EXTI */
00250   ts_driver->EnableIT(I2C_Address);
00251 
00252   return (ts_status);
00253 }
00254 
00255 /**
00256   * @brief  Returns status and positions of the touch screen.
00257   * @param  TS_State: Pointer to touch screen current state structure
00258   * @retval TS_OK if all initializations are OK. Other value if error.
00259   */
00260 uint8_t BSP_TS_GetState(TS_StateTypeDef *TS_State)
00261 {
00262   static uint32_t _x[TS_MAX_NB_TOUCH] = {0, 0};
00263   static uint32_t _y[TS_MAX_NB_TOUCH] = {0, 0};
00264   uint8_t ts_status = TS_OK;
00265   uint16_t tmp;
00266   uint16_t Raw_x[TS_MAX_NB_TOUCH];
00267   uint16_t Raw_y[TS_MAX_NB_TOUCH];
00268   uint16_t xDiff;
00269   uint16_t yDiff;
00270   uint32_t index;
00271 #if (TS_MULTI_TOUCH_SUPPORTED == 1)
00272   uint32_t weight = 0;
00273   uint32_t area = 0;
00274   uint32_t event = 0;
00275 #endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
00276 
00277   /* Check and update the number of touches active detected */
00278   TS_State->touchDetected = ts_driver->DetectTouch(I2C_Address);
00279   if(TS_State->touchDetected)
00280   {
00281     for(index=0; index < TS_State->touchDetected; index++)
00282     {
00283       /* Get each touch coordinates */
00284       ts_driver->GetXY(I2C_Address, &(Raw_x[index]), &(Raw_y[index]));
00285 
00286       if(ts_orientation & TS_SWAP_XY)
00287       {
00288         tmp = Raw_x[index];
00289         Raw_x[index] = Raw_y[index]; 
00290         Raw_y[index] = tmp;
00291       }
00292       
00293       if(ts_orientation & TS_SWAP_X)
00294       {
00295         Raw_x[index] = FT_6206_MAX_WIDTH - 1 - Raw_x[index];
00296       }
00297 
00298       if(ts_orientation & TS_SWAP_Y)
00299       {
00300         Raw_y[index] = FT_6206_MAX_HEIGHT - 1 - Raw_y[index];
00301       }
00302             
00303       xDiff = Raw_x[index] > _x[index]? (Raw_x[index] - _x[index]): (_x[index] - Raw_x[index]);
00304       yDiff = Raw_y[index] > _y[index]? (Raw_y[index] - _y[index]): (_y[index] - Raw_y[index]);
00305 
00306       if ((xDiff + yDiff) > 5)
00307       {
00308         _x[index] = Raw_x[index];
00309         _y[index] = Raw_y[index];
00310       }
00311 
00312 
00313       TS_State->touchX[index] = _x[index];
00314       TS_State->touchY[index] = _y[index];
00315 
00316 #if (TS_MULTI_TOUCH_SUPPORTED == 1)
00317 
00318       /* Get touch info related to the current touch */
00319       ft6x06_TS_GetTouchInfo(I2C_Address, index, &weight, &area, &event);
00320 
00321       /* Update TS_State structure */
00322       TS_State->touchWeight[index] = weight;
00323       TS_State->touchArea[index]   = area;
00324 
00325       /* Remap touch event */
00326       switch(event)
00327       {
00328         case FT6206_TOUCH_EVT_FLAG_PRESS_DOWN  :
00329           TS_State->touchEventId[index] = TOUCH_EVENT_PRESS_DOWN;
00330           break;
00331         case FT6206_TOUCH_EVT_FLAG_LIFT_UP :
00332           TS_State->touchEventId[index] = TOUCH_EVENT_LIFT_UP;
00333           break;
00334         case FT6206_TOUCH_EVT_FLAG_CONTACT :
00335           TS_State->touchEventId[index] = TOUCH_EVENT_CONTACT;
00336           break;
00337         case FT6206_TOUCH_EVT_FLAG_NO_EVENT :
00338           TS_State->touchEventId[index] = TOUCH_EVENT_NO_EVT;
00339           break;
00340         default :
00341           ts_status = TS_ERROR;
00342           break;
00343       } /* of switch(event) */
00344 
00345 #endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
00346 
00347     } /* of for(index=0; index < TS_State->touchDetected; index++) */
00348 
00349 #if (TS_MULTI_TOUCH_SUPPORTED == 1)
00350     /* Get gesture Id */
00351     ts_status = BSP_TS_Get_GestureId(TS_State);
00352 #endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
00353 
00354   } /* end of if(TS_State->touchDetected != 0) */
00355 
00356   return (ts_status);
00357 }
00358 
00359 #if (TS_MULTI_TOUCH_SUPPORTED == 1)
00360 /**
00361   * @brief  Update gesture Id following a touch detected.
00362   * @param  TS_State: Pointer to touch screen current state structure
00363   * @retval TS_OK if all initializations are OK. Other value if error.
00364   */
00365 uint8_t BSP_TS_Get_GestureId(TS_StateTypeDef *TS_State)
00366 {
00367   uint32_t gestureId = 0;
00368   uint8_t  ts_status = TS_OK;
00369 
00370   /* Get gesture Id */
00371   ft6x06_TS_GetGestureID(I2C_Address, &gestureId);
00372 
00373   /* Remap gesture Id to a TS_GestureIdTypeDef value */
00374   switch(gestureId)
00375   {
00376     case FT6206_GEST_ID_NO_GESTURE :
00377       TS_State->gestureId = GEST_ID_NO_GESTURE;
00378       break;
00379     case FT6206_GEST_ID_MOVE_UP :
00380       TS_State->gestureId = GEST_ID_MOVE_UP;
00381       break;
00382     case FT6206_GEST_ID_MOVE_RIGHT :
00383       TS_State->gestureId = GEST_ID_MOVE_RIGHT;
00384       break;
00385     case FT6206_GEST_ID_MOVE_DOWN :
00386       TS_State->gestureId = GEST_ID_MOVE_DOWN;
00387       break;
00388     case FT6206_GEST_ID_MOVE_LEFT :
00389       TS_State->gestureId = GEST_ID_MOVE_LEFT;
00390       break;
00391     case FT6206_GEST_ID_ZOOM_IN :
00392       TS_State->gestureId = GEST_ID_ZOOM_IN;
00393       break;
00394     case FT6206_GEST_ID_ZOOM_OUT :
00395       TS_State->gestureId = GEST_ID_ZOOM_OUT;
00396       break;
00397     default :
00398       ts_status = TS_ERROR;
00399       break;
00400   } /* of switch(gestureId) */
00401 
00402   return(ts_status);
00403 }
00404 #endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
00405 
00406 
00407 /** @defgroup STM32F769I_DISCOVERY_TS_Private_Functions TS Private Functions
00408   * @{
00409   */
00410 
00411 #if (TS_MULTI_TOUCH_SUPPORTED == 1)
00412 /**
00413   * @brief  Function used to reset all touch data before a new acquisition
00414   *         of touch information.
00415   * @param  TS_State: Pointer to touch screen current state structure
00416   * @retval TS_OK if OK, TE_ERROR if problem found.
00417   */
00418 uint8_t BSP_TS_ResetTouchData(TS_StateTypeDef *TS_State)
00419 {
00420   uint8_t ts_status = TS_ERROR;
00421   uint32_t index;
00422 
00423   if (TS_State != (TS_StateTypeDef *)NULL)
00424   {
00425     TS_State->gestureId = GEST_ID_NO_GESTURE;
00426     TS_State->touchDetected = 0;
00427 
00428     for(index = 0; index < TS_MAX_NB_TOUCH; index++)
00429     {
00430       TS_State->touchX[index]       = 0;
00431       TS_State->touchY[index]       = 0;
00432       TS_State->touchArea[index]    = 0;
00433       TS_State->touchEventId[index] = TOUCH_EVENT_NO_EVT;
00434       TS_State->touchWeight[index]  = 0;
00435     }
00436 
00437     ts_status = TS_OK;
00438 
00439   } /* of if (TS_State != (TS_StateTypeDef *)NULL) */
00440 
00441   return (ts_status);
00442 }
00443 #endif /* TS_MULTI_TOUCH_SUPPORTED == 1 */
00444 
00445 /**
00446   * @brief  Initializes the TS_INT pin MSP.
00447   * @retval None
00448   */
00449 __weak void BSP_TS_INT_MspInit(void)
00450 {
00451   GPIO_InitTypeDef  gpio_init_structure;
00452 
00453   TS_INT_GPIO_CLK_ENABLE();
00454 
00455   /* GPIO configuration in input for TouchScreen interrupt signal on TS_INT pin */
00456   gpio_init_structure.Pin       = TS_INT_PIN;
00457 
00458   gpio_init_structure.Mode      = GPIO_MODE_INPUT;
00459   gpio_init_structure.Pull      = GPIO_PULLUP;
00460   gpio_init_structure.Speed     = GPIO_SPEED_HIGH;
00461   HAL_GPIO_Init(TS_INT_GPIO_PORT, &gpio_init_structure);
00462 }
00463 
00464 /**
00465   * @}
00466   */
00467 
00468 /**
00469   * @}
00470   */
00471 
00472 /**
00473   * @}
00474   */
00475 
00476 /**
00477   * @}
00478   */
00479 
00480 /**
00481   * @}
00482   */
00483 
00484 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/