drivers/lcd/tft/touchscreen.c

   1 /**************************************************************************/
   2 /*!
   3     @file     touchscreen.c
   4     @author   K. Townsend (microBuilder.eu)
   5
   6     Parts copyright (c) 2001, Carlos E. Vidales. All rights reserved.
   7
   8     @section LICENSE
   9
  10     Software License Agreement (BSD License)
  11
  12     Copyright (c) 2010, microBuilder SARL
  13     All rights reserved.
  14
  15     Redistribution and use in source and binary forms, with or without
  16     modification, are permitted provided that the following conditions are met:
  17     1. Redistributions of source code must retain the above copyright
  18     notice, this list of conditions and the following disclaimer.
  19     2. Redistributions in binary form must reproduce the above copyright
  20     notice, this list of conditions and the following disclaimer in the
  21     documentation and/or other materials provided with the distribution.
  22     3. Neither the name of the copyright holders nor the
  23     names of its contributors may be used to endorse or promote products
  24     derived from this software without specific prior written permission.
  25
  26     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
  27     EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  28     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  29     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
  30     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  31     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  33     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36 */
  37 /**************************************************************************/
  38 #include "touchscreen.h"
  39
  40 #include "core/adc/adc.h"
  41 #include "core/gpio/gpio.h"
  42 #include "core/systick/systick.h"
  43 #include "drivers/eeprom/eeprom.h"
  44 #include "drivers/lcd/tft/lcd.h"
  45 #include "drivers/lcd/tft/drawing.h"
  46 #include "drivers/lcd/tft/fonts/dejavusans9.h"
  47
  48 #define TS_LINE1 "Touch the center of"
  49 #define TS_LINE2 "the red circle using"
  50 #define TS_LINE3 "a pen or stylus"
  51
  52 static bool _tsInitialised = FALSE;
  53 static uint8_t _tsThreshhold = CFG_TFTLCD_TS_DEFAULTTHRESHOLD;
  54 tsPoint_t _tsLCDPoints[3];
  55 tsPoint_t _tsTSPoints[3];
  56 tsMatrix_t _tsMatrix;
  57
  58 /**************************************************************************/
  59 /*                                                                        */
  60 /* ----------------------- Private Methods ------------------------------ */
  61 /*                                                                        */
  62 /**************************************************************************/
  63
  64 /**************************************************************************/
  65 /*!
  66     @brief  Reads the current Z/pressure level using the ADC
  67 */
  68 /**************************************************************************/
  69 void tsReadZ(uint32_t* z1, uint32_t* z2)
  70 {
  71   if (!_tsInitialised) tsInit();
  72
  73   // XP = ADC
  74   // XM = GPIO Output Low
  75   // YP = GPIO Output High
  76   // YM = GPIO Input
  77
  78   TS_XM_FUNC_GPIO;
  79   TS_YP_FUNC_GPIO;
  80   TS_YM_FUNC_GPIO;
  81
  82   gpioSetDir (TS_XM_PORT, TS_XM_PIN, 1);
  83   gpioSetDir (TS_YP_PORT, TS_YP_PIN, 1);
  84   gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);
  85
  86   gpioSetValue(TS_XM_PORT, TS_XM_PIN, 0);   // GND
  87   gpioSetValue(TS_YP_PORT, TS_YP_PIN, 1);   // 3.3V
  88
  89   TS_XP_FUNC_ADC;
  90   *z1 = adcRead(TS_XP_ADC_CHANNEL);
  91
  92   // XP = GPIO Input
  93   // XM = GPIO Output Low
  94   // YP = GPIO Output High
  95   // YM = ADC
  96
  97   TS_XP_FUNC_GPIO;
  98   gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);
  99
 100   TS_YM_FUNC_ADC;
 101   *z2 = adcRead(TS_YM_ADC_CHANNEL);
 102 }
 103
 104 /**************************************************************************/
 105 /*!
 106     @brief  Reads the current X position using the ADC
 107 */
 108 /**************************************************************************/
 109 uint32_t tsReadX(void)
 110 {
 111   if (!_tsInitialised) tsInit();
 112
 113   // XP = GPIO Output High
 114   // XM = GPIO Output Low
 115   // YP = ADC
 116   // YM = GPIO Input
 117
 118   TS_XP_FUNC_GPIO;
 119   TS_XM_FUNC_GPIO;
 120   TS_YM_FUNC_GPIO;
 121
 122   gpioSetDir (TS_XP_PORT, TS_XP_PIN, 1);
 123   gpioSetDir (TS_XM_PORT, TS_XM_PIN, 1);
 124   gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);
 125
 126   gpioSetValue(TS_XP_PORT, TS_XP_PIN, 1);   // 3.3V
 127   gpioSetValue(TS_XM_PORT, TS_XM_PIN, 0);   // GND
 128
 129   TS_YP_FUNC_ADC;
 130
 131   // Return the ADC results
 132   return adcRead(TS_YP_ADC_CHANNEL);
 133 }
 134
 135 /**************************************************************************/
 136 /*!
 137     @brief  Reads the current Y position using the ADC
 138 */
 139 /**************************************************************************/
 140 uint32_t tsReadY(void)
 141 {
 142   if (!_tsInitialised) tsInit();
 143
 144   // YP = GPIO Output High
 145   // YM = GPIO Output Low
 146   // XP = GPIO Input
 147   // XM = ADC
 148
 149   TS_YP_FUNC_GPIO;
 150   TS_YM_FUNC_GPIO;
 151   TS_XP_FUNC_GPIO;
 152
 153   gpioSetDir (TS_YP_PORT, TS_YP_PIN, 1);
 154   gpioSetDir (TS_YM_PORT, TS_YM_PIN, 1);
 155   gpioSetDir (TS_XP_PORT, TS_XP_PIN, 0);
 156
 157   gpioSetValue(TS_YP_PORT, TS_YP_PIN, 1);   // 3.3V
 158   gpioSetValue(TS_YM_PORT, TS_YM_PIN, 0);   // GND
 159
 160   TS_XM_FUNC_ADC;
 161
 162   // Return the ADC results
 163   return adcRead(TS_XM_ADC_CHANNEL);
 164 }
 165
 166 /**************************************************************************/
 167 /*!
 168     @brief  Centers a line of text horizontally
 169 */
 170 /**************************************************************************/
 171 void tsCalibCenterText(char* text, uint16_t y, uint16_t color)
 172 {
 173   drawString((lcdGetWidth() - drawGetStringWidth(&dejaVuSans9ptFontInfo, text)) / 2, y, color, &dejaVuSans9ptFontInfo, text);
 174 }
 175
 176 /**************************************************************************/
 177 /*!
 178     @brief  Renders the calibration screen with an appropriately
 179             placed test point and waits for a touch event
 180 */
 181 /**************************************************************************/
 182 tsTouchData_t tsRenderCalibrationScreen(uint16_t x, uint16_t y, uint16_t radius)
 183 {
 184   drawFill(COLOR_WHITE);
 185   tsCalibCenterText(TS_LINE1, 50, COLOR_GRAY_50);
 186   tsCalibCenterText(TS_LINE2, 65, COLOR_GRAY_50);
 187   tsCalibCenterText(TS_LINE3, 80, COLOR_GRAY_50);
 188   drawCircle(x, y, radius, COLOR_RED);
 189   drawCircle(x, y, radius + 2, COLOR_GRAY_128);
 190
 191   // Wait for a valid touch events
 192   tsTouchData_t data;
 193   tsTouchError_t error;
 194   bool valid = false;
 195   while (!valid)
 196   {
 197     error = tsRead(&data);
 198     if (!error && data.valid)
 199     {
 200       valid = true;
 201     }
 202   }
 203
 204   return data;
 205 }
 206
 207 /**************************************************************************/
 208 /*!
 209     @brief Calculates the difference between the touch screen and the
 210            actual screen co-ordinates, taking into account misalignment
 211            and any physical offset of the touch screen.
 212
 213     @note  This is based on the public domain touch screen calibration code
 214            written by Carlos E. Vidales (copyright (c) 2001).
 215
 216            For more information, see the following app notes:
 217
 218            - AN2173 - Touch Screen Control and Calibration
 219              Svyatoslav Paliy, Cypress Microsystems
 220            - Calibration in touch-screen systems
 221              Wendy Fang and Tony Chang,
 222              Analog Applications Journal, 3Q 2007 (Texas Instruments)
 223 */
 224 /**************************************************************************/
 225 int setCalibrationMatrix( tsPoint_t * displayPtr, tsPoint_t * screenPtr, tsMatrix_t * matrixPtr)
 226 {
 227   int  retValue = 0;
 228
 229   matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
 230                        ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
 231
 232   if( matrixPtr->Divider == 0 )
 233   {
 234     retValue = -1 ;
 235   }
 236   else
 237   {
 238     matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
 239                     ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
 240
 241     matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
 242                     ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
 243
 244     matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
 245                     (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
 246                     (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
 247
 248     matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
 249                     ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
 250
 251     matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
 252                     ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
 253
 254     matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
 255                     (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
 256                     (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
 257
 258     // Persist data to EEPROM
 259     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN, matrixPtr->An);
 260     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN, matrixPtr->Bn);
 261     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN, matrixPtr->Cn);
 262     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN, matrixPtr->Dn);
 263     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN, matrixPtr->En);
 264     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN, matrixPtr->Fn);
 265     eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER, matrixPtr->Divider);
 266     eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED, 1);
 267   }
 268
 269   return( retValue ) ;
 270 }
 271
 272 /**************************************************************************/
 273 /*!
 274     @brief  Converts the supplied touch screen location (screenPtr) to
 275             a pixel location on the display (displayPtr) using the
 276             supplied matrix.  The screen orientation is also taken into
 277             account when converting the touch screen co-ordinate to
 278             a pixel location on the LCD.
 279
 280     @note  This is based on the public domain touch screen calibration code
 281            written by Carlos E. Vidales (copyright (c) 2001).
 282 */
 283 /**************************************************************************/
 284 int getDisplayPoint( tsPoint_t * displayPtr, tsPoint_t * screenPtr, tsMatrix_t * matrixPtr )
 285 {
 286   int  retValue = 0 ;
 287
 288   if( matrixPtr->Divider != 0 )
 289   {
 290     displayPtr->x = ( (matrixPtr->An * screenPtr->x) +
 291                       (matrixPtr->Bn * screenPtr->y) +
 292                        matrixPtr->Cn
 293                     ) / matrixPtr->Divider ;
 294
 295     displayPtr->y = ( (matrixPtr->Dn * screenPtr->x) +
 296                       (matrixPtr->En * screenPtr->y) +
 297                        matrixPtr->Fn
 298                     ) / matrixPtr->Divider ;
 299   }
 300   else
 301   {
 302     retValue = -1 ;
 303   }
 304
 305   // Adjust value if the screen is in landscape mode
 306   lcdOrientation_t orientation;
 307   orientation = lcdGetOrientation();
 308   if (orientation == LCD_ORIENTATION_LANDSCAPE)
 309   {
 310       uint32_t oldx, oldy;
 311       oldx = displayPtr->x;
 312       oldy = displayPtr->y;
 313       displayPtr->x = oldy;
 314       displayPtr->y = lcdGetHeight() - oldx;
 315   }
 316
 317   return( retValue ) ;
 318 }
 319
 320 /**************************************************************************/
 321 /*                                                                        */
 322 /* ----------------------- Public Methods ------------------------------- */
 323 /*                                                                        */
 324 /**************************************************************************/
 325
 326 /**************************************************************************/
 327 /*!
 328     @brief  Initialises the appropriate GPIO pins and ADC for the
 329             touchscreen
 330 */
 331 /**************************************************************************/
 332 void tsInit(void)
 333 {
 334   // Make sure that ADC is initialised
 335   adcInit();
 336
 337   // Set initialisation flag
 338   _tsInitialised = TRUE;
 339   _tsThreshhold = tsGetThreshhold();
 340
 341   // Load values from EEPROM if touch screen has already been calibrated
 342   if (eepromReadU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED) == 1)
 343   {
 344     // Load calibration data
 345     _tsMatrix.An = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN);
 346     _tsMatrix.Bn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN);
 347     _tsMatrix.Cn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN);
 348     _tsMatrix.Dn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN);
 349     _tsMatrix.En = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN);
 350     _tsMatrix.Fn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN);
 351     _tsMatrix.Divider = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER);
 352   }
 353 }
 354
 355 /**************************************************************************/
 356 /*!
 357     @brief  Reads the current X, Y and Z co-ordinates of the touch screen
 358 */
 359 /**************************************************************************/
 360 tsTouchError_t tsRead(tsTouchData_t* data)
 361 {
 362   uint32_t x1, x2, y1, y2, z1, z2;
 363
 364   // Assign pressure levels regardless of touch state
 365   tsReadZ(&z1, &z2);
 366   data->z1 = z1;
 367   data->z2 = z2;
 368   data->xraw = 0;
 369   data->yraw = 0;
 370   data->xlcd = 0;
 371   data->ylcd = 0;
 372
 373   // Abort if the screen is not being touched (0 levels reported)
 374   if (z1 < _tsThreshhold)
 375   {
 376     data->valid = false;
 377     return TS_ERROR_NONE;
 378   }
 379
 380   // Get two X/Y readings and compare results
 381   x1 = tsReadX();
 382   x2 = tsReadX();
 383   y1 = tsReadY();
 384   y2 = tsReadY();
 385
 386   // Throw an error if both readings aren't identical
 387   if (x1 != x2 || y1 != y2)
 388   {
 389     data->valid = false;
 390     data->xraw = x1;
 391     data->yraw = y1;
 392     return TS_ERROR_XYMISMATCH;
 393   }
 394
 395   // X/Y seems to be valid and reading has been confirmed twice
 396   data->xraw = x1;
 397   data->yraw = y1;
 398
 399   // Convert x/y values to pixel location with matrix multiply
 400   tsPoint_t location, touch;
 401   touch.x = x1;
 402   touch.y = y1;
 403   getDisplayPoint( &location, &touch, &_tsMatrix) ;
 404   data->xlcd = location.x;
 405   data->ylcd = location.y;
 406   data->valid = true;
 407
 408   return TS_ERROR_NONE;
 409 }
 410
 411 /**************************************************************************/
 412 /*!
 413     @brief  Starts the screen calibration process.  Each corner will be
 414             tested, meaning that each boundary (top, left, right and
 415             bottom) will be tested twice and the readings averaged.
 416 */
 417 /**************************************************************************/
 418 void tsCalibrate(void)
 419 {
 420   tsTouchData_t data;
 421
 422   /* --------------- Welcome Screen --------------- */
 423   data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() / 2, 5);
 424   systickDelay(250);
 425
 426   /* ----------------- First Dot ------------------ */
 427   // 10% over and 10% down
 428   data = tsRenderCalibrationScreen(lcdGetWidth() / 10, lcdGetHeight() / 10, 5);
 429   _tsLCDPoints[0].x = lcdGetWidth() / 10;
 430   _tsLCDPoints[0].y = lcdGetHeight() / 10;
 431   _tsTSPoints[0].x = data.xraw;
 432   _tsTSPoints[0].y = data.yraw;
 433   printf("Point 1 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
 434         (int)_tsLCDPoints[0].x, (int)_tsLCDPoints[0].y, (int)_tsTSPoints[0].x, (int)_tsTSPoints[0].y);
 435   systickDelay(250);
 436
 437   /* ---------------- Second Dot ------------------ */
 438   // 50% over and 90% down
 439   data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() - lcdGetHeight() / 10, 5);
 440   _tsLCDPoints[1].x = lcdGetWidth() / 2;
 441   _tsLCDPoints[1].y = lcdGetHeight() - lcdGetHeight() / 10;
 442   _tsTSPoints[1].x = data.xraw;
 443   _tsTSPoints[1].y = data.yraw;
 444   printf("Point 2 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
 445        (int)_tsLCDPoints[1].x, (int)_tsLCDPoints[1].y, (int)_tsTSPoints[1].x, (int)_tsTSPoints[1].y);
 446   systickDelay(250);
 447
 448   /* ---------------- Third Dot ------------------- */
 449   // 90% over and 50% down
 450   data = tsRenderCalibrationScreen(lcdGetWidth() - lcdGetWidth() / 10, lcdGetHeight() / 2, 5);
 451   _tsLCDPoints[2].x = lcdGetWidth() - lcdGetWidth() / 10;
 452   _tsLCDPoints[2].y = lcdGetHeight() / 2;
 453   _tsTSPoints[2].x = data.xraw;
 454   _tsTSPoints[2].y = data.yraw;
 455   printf("Point 3 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
 456         (int)_tsLCDPoints[2].x, (int)_tsLCDPoints[2].y, (int)_tsTSPoints[2].x, (int)_tsTSPoints[2].y);
 457   systickDelay(250);
 458
 459   // Do matrix calculations for calibration and store to EEPROM
 460   setCalibrationMatrix(&_tsLCDPoints[0], &_tsTSPoints[0], &_tsMatrix);
 461 }
 462
 463 /**************************************************************************/
 464 /*!
 465     @brief  Causes a blocking delay until a valid touch event occurs
 466
 467     @note   Thanks to 'rossum' and limor for this nifty little tidbit on
 468             debouncing the signals via pressure sensitivity (using Z)
 469
 470     @section Example
 471
 472     @code
 473     #include "drivers/lcd/tft/touchscreen.h"
 474     ...
 475     tsTouchData_t data;
 476     tsTouchError_t error;
 477
 478     while (1)
 479     {
 480       // Cause a blocking delay until a touch event occurs or 5s passes
 481       error = tsWaitForEvent(&data, 5000);
 482
 483       if (error)
 484       {
 485         switch(error)
 486         {
 487           case TS_ERROR_TIMEOUT:
 488             printf("Timeout occurred %s", CFG_PRINTF_NEWLINE);
 489             break;
 490           default:
 491             break;
 492         }
 493       }
 494       else
 495       {
 496         // A valid touch event occurred ... display data
 497         printf("Touch Event: X = %04u, Y = %04u %s",
 498             data.xlcd,
 499             data.ylcd,
 500             CFG_PRINTF_NEWLINE);
 501       }
 502     }
 503
 504     @endcode
 505 */
 506 /**************************************************************************/
 507 tsTouchError_t tsWaitForEvent(tsTouchData_t* data, uint32_t timeoutMS)
 508 {
 509   if (!_tsInitialised) tsInit();
 510
 511   tsRead(data);
 512
 513   // Return the results right away if reading is valid
 514   if (data->valid)
 515   {
 516     return TS_ERROR_NONE;
 517   }
 518
 519   // Handle timeout if delay > 0 milliseconds
 520   if (timeoutMS)
 521   {
 522     uint32_t startTick = systickGetTicks();
 523     // Systick rollover may occur while waiting for timeout
 524     if (startTick > 0xFFFFFFFF - timeoutMS)
 525     {
 526       while (data->valid == false)
 527       {
 528         // Throw alert if timeout delay has been passed
 529         if ((systickGetTicks() < startTick) && (systickGetTicks() >= (timeoutMS - (0xFFFFFFFF - startTick))))
 530         {
 531           return TS_ERROR_TIMEOUT;
 532         }
 533         tsRead(data);
 534       }
 535     }
 536     // No systick rollover will occur ... calculate timeout the simple way
 537     else
 538     {
 539       // Wait in infinite loop
 540       while (data->valid == false)
 541       {
 542         // Throw timeout if delay has been passed
 543         if ((systickGetTicks() - startTick) > timeoutMS)
 544         {
 545           return TS_ERROR_TIMEOUT;
 546         }
 547         tsRead(data);
 548       }
 549     }
 550   }
 551   // No timeout requested ... wait forever
 552   else
 553   {
 554     while (data->valid == false)
 555     {
 556       tsRead(data);
 557     }
 558   }
 559
 560   // Indicate correct reading
 561   return TS_ERROR_NONE;
 562 }
 563
 564 /**************************************************************************/
 565 /*!
 566     @brief  Updates the touch screen threshhold level and saves it
 567             to EEPROM
 568 */
 569 /**************************************************************************/
 570 int tsSetThreshhold(uint8_t value)
 571 {
 572   if ((value < 0) || (value > 254))
 573   {
 574     return -1;
 575   }
 576
 577   // Update threshhold value
 578   _tsThreshhold = value;
 579
 580   // Persist to EEPROM
 581   eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD, value);
 582
 583   return 0;
 584 }
 585
 586 /**************************************************************************/
 587 /*!
 588     @brief  Gets the current touch screen threshhold level from EEPROM
 589             (if present) or returns the default value from projectconfig.h
 590 */
 591 /**************************************************************************/
 592 uint8_t tsGetThreshhold(void)
 593 {
 594   // Check if custom threshold has been set in eeprom
 595   uint8_t thold = eepromReadU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD);
 596   if (thold != 0xFF)
 597   {
 598     // Use value from EEPROM
 599     _tsThreshhold = thold;
 600   }
 601   else
 602   {
 603     // Use the default value from projectconfig.h
 604     _tsThreshhold = CFG_TFTLCD_TS_DEFAULTTHRESHOLD;
 605   }
 606
 607   return _tsThreshhold;
 608 }