projects / hackover2013-badge-firmware.git / blob
? search:


3370c5f43f8a86a22b0a71000c9948baf28b6d07
[hackover2013-badge-firmware.git] / drivers / displays / 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/storage/eeprom/eeprom.h"
44 #include "drivers/displays/tft/lcd.h"
45 #include "drivers/displays/tft/drawing.h"
46 #include "drivers/displays/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 // Set calibration flag for ts read
198 error = tsRead(&data, true);
199 if (!error && data.valid)
200 {
201 valid = true;
202 }
203 }
204
205 return data;
206 }
207
208 /**************************************************************************/
209 /*!
210 @brief Calculates the difference between the touch screen and the
211 actual screen co-ordinates, taking into account misalignment
212 and any physical offset of the touch screen.
213
214 @note This is based on the public domain touch screen calibration code
215 written by Carlos E. Vidales (copyright (c) 2001).
216
217 For more information, see the following app notes:
218
219 - AN2173 - Touch Screen Control and Calibration
220 Svyatoslav Paliy, Cypress Microsystems
221 - Calibration in touch-screen systems
222 Wendy Fang and Tony Chang,
223 Analog Applications Journal, 3Q 2007 (Texas Instruments)
224 */
225 /**************************************************************************/
226 int setCalibrationMatrix( tsPoint_t * displayPtr, tsPoint_t * screenPtr, tsMatrix_t * matrixPtr)
227 {
228 int retValue = 0;
229
230 matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
231 ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
232
233 if( matrixPtr->Divider == 0 )
234 {
235 retValue = -1 ;
236 }
237 else
238 {
239 matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
240 ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
241
242 matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
243 ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
244
245 matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
246 (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
247 (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
248
249 matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
250 ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
251
252 matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
253 ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
254
255 matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
256 (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
257 (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
258
259 // Persist data to EEPROM
260 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN, matrixPtr->An);
261 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN, matrixPtr->Bn);
262 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN, matrixPtr->Cn);
263 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN, matrixPtr->Dn);
264 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN, matrixPtr->En);
265 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN, matrixPtr->Fn);
266 eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER, matrixPtr->Divider);
267 eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED, 1);
268 }
269
270 return( retValue ) ;
271 }
272
273 /**************************************************************************/
274 /*!
275 @brief Converts the supplied touch screen location (screenPtr) to
276 a pixel location on the display (displayPtr) using the
277 supplied matrix. The screen orientation is also taken into
278 account when converting the touch screen co-ordinate to
279 a pixel location on the LCD.
280
281 @note This is based on the public domain touch screen calibration code
282 written by Carlos E. Vidales (copyright (c) 2001).
283 */
284 /**************************************************************************/
285 int getDisplayPoint( tsPoint_t * displayPtr, tsPoint_t * screenPtr, tsMatrix_t * matrixPtr )
286 {
287 int retValue = TS_ERROR_NONE ;
288
289 if( matrixPtr->Divider != 0 )
290 {
291 displayPtr->x = ( (matrixPtr->An * screenPtr->x) +
292 (matrixPtr->Bn * screenPtr->y) +
293 matrixPtr->Cn
294 ) / matrixPtr->Divider ;
295
296 displayPtr->y = ( (matrixPtr->Dn * screenPtr->x) +
297 (matrixPtr->En * screenPtr->y) +
298 matrixPtr->Fn
299 ) / matrixPtr->Divider ;
300 }
301 else
302 {
303 // ToDo: Default values required or you can never read LCD position!
304 // return TS_ERROR_NOTCALIBRATED;
305 return -1;
306 }
307
308 // Adjust value if the screen is in landscape mode
309 lcdOrientation_t orientation;
310 orientation = lcdGetOrientation();
311 if (orientation == LCD_ORIENTATION_LANDSCAPE)
312 {
313 uint32_t oldx, oldy;
314 oldx = displayPtr->x;
315 oldy = displayPtr->y;
316 displayPtr->x = oldy;
317 displayPtr->y = lcdGetHeight() - oldx;
318 }
319
320 return( retValue ) ;
321 }
322
323 /**************************************************************************/
324 /* */
325 /* ----------------------- Public Methods ------------------------------- */
326 /* */
327 /**************************************************************************/
328
329 /**************************************************************************/
330 /*!
331 @brief Initialises the appropriate GPIO pins and ADC for the
332 touchscreen
333 */
334 /**************************************************************************/
335 void tsInit(void)
336 {
337 // Make sure that ADC is initialised
338 adcInit();
339
340 // Set initialisation flag
341 _tsInitialised = TRUE;
342 _tsThreshhold = tsGetThreshhold();
343
344 // Load values from EEPROM if touch screen has already been calibrated
345 if (eepromReadU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED) == 1)
346 {
347 // Load calibration data
348 _tsMatrix.An = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN);
349 _tsMatrix.Bn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN);
350 _tsMatrix.Cn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN);
351 _tsMatrix.Dn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN);
352 _tsMatrix.En = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN);
353 _tsMatrix.Fn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN);
354 _tsMatrix.Divider = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER);
355 }
356 else
357 {
358 // You may want to run the touch screen calibration sequence
359 // here since the ts has apparently never been calibrated!
360 // tsCalibrate();
361 }
362 }
363
364 /**************************************************************************/
365 /*!
366 @brief Reads the current X, Y and Z co-ordinates of the touch screen
367
368 @param[in] calibrating
369 Set to 1 if the read attempt is for calibration data.
370 No attempt will be made to correlate the touch screen
371 and LCD co-ordinates.
372 */
373 /**************************************************************************/
374 tsTouchError_t tsRead(tsTouchData_t* data, uint8_t calibrating)
375 {
376 uint32_t x1, x2, y1, y2, z1, z2;
377
378 // Assign pressure levels regardless of touch state
379 tsReadZ(&z1, &z2);
380 data->z1 = z1;
381 data->z2 = z2;
382 data->xraw = 0;
383 data->yraw = 0;
384 data->xlcd = 0;
385 data->ylcd = 0;
386
387 // Abort if the screen is not being touched (0 levels reported)
388 if (z1 < _tsThreshhold)
389 {
390 data->valid = false;
391 return TS_ERROR_NONE;
392 }
393
394 // Get two X/Y readings and compare results
395 x1 = tsReadX();
396 x2 = tsReadX();
397 y1 = tsReadY();
398 y2 = tsReadY();
399
400 // Throw an error if both readings aren't identical
401 if (x1 != x2 || y1 != y2)
402 {
403 data->valid = false;
404 data->xraw = x1;
405 data->yraw = y1;
406 return TS_ERROR_XYMISMATCH;
407 }
408
409 // X/Y seems to be valid and reading has been confirmed twice
410 data->xraw = x1;
411 data->yraw = y1;
412
413 // Convert x/y values to pixel location with matrix multiply
414 tsPoint_t location, touch;
415 touch.x = x1;
416 touch.y = y1;
417 // Only calculate the relative LCD value if this isn't for calibration
418 if (!calibrating)
419 {
420 getDisplayPoint( &location, &touch, &_tsMatrix) ;
421 data->xlcd = location.x;
422 data->ylcd = location.y;
423 }
424 else
425 {
426 // Assign some false values, but only xraw and yraw are
427 // used for calibration
428 data->xlcd = 0;
429 data->ylcd = 0;
430 }
431 data->valid = true;
432
433 return TS_ERROR_NONE;
434 }
435
436 /**************************************************************************/
437 /*!
438 @brief Starts the screen calibration process. Each corner will be
439 tested, meaning that each boundary (top, left, right and
440 bottom) will be tested twice and the readings averaged.
441 */
442 /**************************************************************************/
443 void tsCalibrate(void)
444 {
445 tsTouchData_t data;
446
447 /* --------------- Welcome Screen --------------- */
448 data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() / 2, 5);
449 systickDelay(250);
450
451 /* ----------------- First Dot ------------------ */
452 // 10% over and 10% down
453 data = tsRenderCalibrationScreen(lcdGetWidth() / 10, lcdGetHeight() / 10, 5);
454 _tsLCDPoints[0].x = lcdGetWidth() / 10;
455 _tsLCDPoints[0].y = lcdGetHeight() / 10;
456 _tsTSPoints[0].x = data.xraw;
457 _tsTSPoints[0].y = data.yraw;
458 printf("Point 1 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
459 (int)_tsLCDPoints[0].x, (int)_tsLCDPoints[0].y, (int)_tsTSPoints[0].x, (int)_tsTSPoints[0].y);
460 systickDelay(250);
461
462 /* ---------------- Second Dot ------------------ */
463 // 50% over and 90% down
464 data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() - lcdGetHeight() / 10, 5);
465 _tsLCDPoints[1].x = lcdGetWidth() / 2;
466 _tsLCDPoints[1].y = lcdGetHeight() - lcdGetHeight() / 10;
467 _tsTSPoints[1].x = data.xraw;
468 _tsTSPoints[1].y = data.yraw;
469 printf("Point 2 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
470 (int)_tsLCDPoints[1].x, (int)_tsLCDPoints[1].y, (int)_tsTSPoints[1].x, (int)_tsTSPoints[1].y);
471 systickDelay(250);
472
473 /* ---------------- Third Dot ------------------- */
474 // 90% over and 50% down
475 data = tsRenderCalibrationScreen(lcdGetWidth() - lcdGetWidth() / 10, lcdGetHeight() / 2, 5);
476 _tsLCDPoints[2].x = lcdGetWidth() - lcdGetWidth() / 10;
477 _tsLCDPoints[2].y = lcdGetHeight() / 2;
478 _tsTSPoints[2].x = data.xraw;
479 _tsTSPoints[2].y = data.yraw;
480 printf("Point 3 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
481 (int)_tsLCDPoints[2].x, (int)_tsLCDPoints[2].y, (int)_tsTSPoints[2].x, (int)_tsTSPoints[2].y);
482 systickDelay(250);
483
484 // Do matrix calculations for calibration and store to EEPROM
485 setCalibrationMatrix(&_tsLCDPoints[0], &_tsTSPoints[0], &_tsMatrix);
486 }
487
488 /**************************************************************************/
489 /*!
490 @brief Causes a blocking delay until a valid touch event occurs
491
492 @note Thanks to 'rossum' and limor for this nifty little tidbit on
493 debouncing the signals via pressure sensitivity (using Z)
494
495 @section Example
496
497 @code
498 #include "drivers/displays/tft/touchscreen.h"
499 ...
500 tsTouchData_t data;
501 tsTouchError_t error;
502
503 while (1)
504 {
505 // Cause a blocking delay until a touch event occurs or 5s passes
506 error = tsWaitForEvent(&data, 5000);
507
508 if (error)
509 {
510 switch(error)
511 {
512 case TS_ERROR_TIMEOUT:
513 printf("Timeout occurred %s", CFG_PRINTF_NEWLINE);
514 break;
515 default:
516 break;
517 }
518 }
519 else
520 {
521 // A valid touch event occurred ... display data
522 printf("Touch Event: X = %04u, Y = %04u %s",
523 data.xlcd,
524 data.ylcd,
525 CFG_PRINTF_NEWLINE);
526 }
527 }
528
529 @endcode
530 */
531 /**************************************************************************/
532 tsTouchError_t tsWaitForEvent(tsTouchData_t* data, uint32_t timeoutMS)
533 {
534 if (!_tsInitialised) tsInit();
535
536 tsRead(data, false);
537
538 // Return the results right away if reading is valid
539 if (data->valid)
540 {
541 return TS_ERROR_NONE;
542 }
543
544 // Handle timeout if delay > 0 milliseconds
545 if (timeoutMS)
546 {
547 uint32_t startTick = systickGetTicks();
548 // Systick rollover may occur while waiting for timeout
549 if (startTick > 0xFFFFFFFF - timeoutMS)
550 {
551 while (data->valid == false)
552 {
553 // Throw alert if timeout delay has been passed
554 if ((systickGetTicks() < startTick) && (systickGetTicks() >= (timeoutMS - (0xFFFFFFFF - startTick))))
555 {
556 return TS_ERROR_TIMEOUT;
557 }
558 tsRead(data, false);
559 }
560 }
561 // No systick rollover will occur ... calculate timeout the simple way
562 else
563 {
564 // Wait in infinite loop
565 while (data->valid == false)
566 {
567 // Throw timeout if delay has been passed
568 if ((systickGetTicks() - startTick) > timeoutMS)
569 {
570 return TS_ERROR_TIMEOUT;
571 }
572 tsRead(data, false);
573 }
574 }
575 }
576 // No timeout requested ... wait forever
577 else
578 {
579 while (data->valid == false)
580 {
581 tsRead(data, false);
582 }
583 }
584
585 // Indicate correct reading
586 return TS_ERROR_NONE;
587 }
588
589 /**************************************************************************/
590 /*!
591 @brief Updates the touch screen threshhold level and saves it
592 to EEPROM
593 */
594 /**************************************************************************/
595 int tsSetThreshhold(uint8_t value)
596 {
597 if ((value < 0) || (value > 254))
598 {
599 return -1;
600 }
601
602 // Update threshhold value
603 _tsThreshhold = value;
604
605 // Persist to EEPROM
606 eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD, value);
607
608 return 0;
609 }
610
611 /**************************************************************************/
612 /*!
613 @brief Gets the current touch screen threshhold level from EEPROM
614 (if present) or returns the default value from projectconfig.h
615 */
616 /**************************************************************************/
617 uint8_t tsGetThreshhold(void)
618 {
619 // Check if custom threshold has been set in eeprom
620 uint8_t thold = eepromReadU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD);
621 if (thold != 0xFF)
622 {
623 // Use value from EEPROM
624 _tsThreshhold = thold;
625 }
626 else
627 {
628 // Use the default value from projectconfig.h
629 _tsThreshhold = CFG_TFTLCD_TS_DEFAULTTHRESHOLD;
630 }
631
632 return _tsThreshhold;
633 }
Unnamed repository; edit this file 'description' to name the repository.
This page took 0.076234 seconds and 3 git commands to generate.