projects / hackover2013-badge-firmware.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Rotorgeschwindigkeit.
[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/controls/labelcentered.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 labelcenteredRender(lcdGetWidth()/2, y, COLOR_WHITE, color, text, themeGetDefault());
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 // return TS_ERROR_NOTCALIBRATED;
304 return -1;
305 }
306
307 // Adjust value if the screen is in landscape mode
308 lcdOrientation_t orientation;
309 orientation = lcdGetOrientation();
310 if (orientation == LCD_ORIENTATION_LANDSCAPE)
311 {
312 uint32_t oldx, oldy;
313 oldx = displayPtr->x;
314 oldy = displayPtr->y;
315 displayPtr->x = oldy;
316 displayPtr->y = lcdGetHeight() - oldx;
317 }
318
319 return( retValue ) ;
320 }
321
322 /**************************************************************************/
323 /* */
324 /* ----------------------- Public Methods ------------------------------- */
325 /* */
326 /**************************************************************************/
327
328 /**************************************************************************/
329 /*!
330 @brief Initialises the appropriate GPIO pins and ADC for the
331 touchscreen
332 */
333 /**************************************************************************/
334 void tsInit(void)
335 {
336 // Make sure that ADC is initialised
337 adcInit();
338
339 // Set initialisation flag
340 _tsInitialised = TRUE;
341 _tsThreshhold = tsGetThreshhold();
342
343 // Load values from EEPROM if touch screen has already been calibrated
344 if (eepromReadU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED) == 1)
345 {
346 // Load calibration data
347 _tsMatrix.An = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN);
348 _tsMatrix.Bn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN);
349 _tsMatrix.Cn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN);
350 _tsMatrix.Dn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN);
351 _tsMatrix.En = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN);
352 _tsMatrix.Fn = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN);
353 _tsMatrix.Divider = eepromReadS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER);
354 }
355 else
356 {
357 // You may want to run the touch screen calibration sequence
358 // here since the ts has apparently never been calibrated!
359 // tsCalibrate();
360 }
361 }
362
363 /**************************************************************************/
364 /*!
365 @brief Reads the current X, Y and Z co-ordinates of the touch screen
366
367 @param[in] calibrating
368 Set to 1 if the read attempt is for calibration data.
369 No attempt will be made to correlate the touch screen
370 and LCD co-ordinates.
371 */
372 /**************************************************************************/
373 tsTouchError_t tsRead(tsTouchData_t* data, uint8_t calibrating)
374 {
375 uint32_t x1, x2, y1, y2, z1, z2;
376
377 // Assign pressure levels regardless of touch state
378 tsReadZ(&z1, &z2);
379 data->z1 = z1;
380 data->z2 = z2;
381 data->xraw = 0;
382 data->yraw = 0;
383 data->xlcd = 0;
384 data->ylcd = 0;
385
386 // Abort if the screen is not being touched (0 levels reported)
387 if (z1 < _tsThreshhold)
388 {
389 data->valid = false;
390 return TS_ERROR_NONE;
391 }
392
393 // Get two X/Y readings and compare results
394 x1 = tsReadX();
395 x2 = tsReadX();
396 y1 = tsReadY();
397 y2 = tsReadY();
398
399 // Throw an error if both readings aren't identical
400 if (x1 != x2 || y1 != y2)
401 {
402 data->valid = false;
403 data->xraw = x1;
404 data->yraw = y1;
405 return TS_ERROR_XYMISMATCH;
406 }
407
408 // X/Y seems to be valid and reading has been confirmed twice
409 data->xraw = x1;
410 data->yraw = y1;
411
412 // Convert x/y values to pixel location with matrix multiply
413 tsPoint_t location, touch;
414 touch.x = x1;
415 touch.y = y1;
416 getDisplayPoint( &location, &touch, &_tsMatrix) ;
417 data->xlcd = location.x;
418 data->ylcd = location.y;
419 data->valid = true;
420
421 return TS_ERROR_NONE;
422 }
423
424 /**************************************************************************/
425 /*!
426 @brief Starts the screen calibration process. Each corner will be
427 tested, meaning that each boundary (top, left, right and
428 bottom) will be tested twice and the readings averaged.
429 */
430 /**************************************************************************/
431 void tsCalibrate(void)
432 {
433 tsTouchData_t data;
434
435 /* --------------- Welcome Screen --------------- */
436 data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() / 2, 5);
437 systickDelay(250);
438
439 /* ----------------- First Dot ------------------ */
440 // 10% over and 10% down
441 data = tsRenderCalibrationScreen(lcdGetWidth() / 10, lcdGetHeight() / 10, 5);
442 _tsLCDPoints[0].x = lcdGetWidth() / 10;
443 _tsLCDPoints[0].y = lcdGetHeight() / 10;
444 _tsTSPoints[0].x = data.xraw;
445 _tsTSPoints[0].y = data.yraw;
446 printf("Point 1 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
447 (int)_tsLCDPoints[0].x, (int)_tsLCDPoints[0].y, (int)_tsTSPoints[0].x, (int)_tsTSPoints[0].y);
448 systickDelay(250);
449
450 /* ---------------- Second Dot ------------------ */
451 // 50% over and 90% down
452 data = tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() - lcdGetHeight() / 10, 5);
453 _tsLCDPoints[1].x = lcdGetWidth() / 2;
454 _tsLCDPoints[1].y = lcdGetHeight() - lcdGetHeight() / 10;
455 _tsTSPoints[1].x = data.xraw;
456 _tsTSPoints[1].y = data.yraw;
457 printf("Point 2 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
458 (int)_tsLCDPoints[1].x, (int)_tsLCDPoints[1].y, (int)_tsTSPoints[1].x, (int)_tsTSPoints[1].y);
459 systickDelay(250);
460
461 /* ---------------- Third Dot ------------------- */
462 // 90% over and 50% down
463 data = tsRenderCalibrationScreen(lcdGetWidth() - lcdGetWidth() / 10, lcdGetHeight() / 2, 5);
464 _tsLCDPoints[2].x = lcdGetWidth() - lcdGetWidth() / 10;
465 _tsLCDPoints[2].y = lcdGetHeight() / 2;
466 _tsTSPoints[2].x = data.xraw;
467 _tsTSPoints[2].y = data.yraw;
468 printf("Point 3 - LCD X:%04d Y:%04d TS X:%04d Y:%04d \r\n",
469 (int)_tsLCDPoints[2].x, (int)_tsLCDPoints[2].y, (int)_tsTSPoints[2].x, (int)_tsTSPoints[2].y);
470 systickDelay(250);
471
472 // Do matrix calculations for calibration and store to EEPROM
473 setCalibrationMatrix(&_tsLCDPoints[0], &_tsTSPoints[0], &_tsMatrix);
474 }
475
476 /**************************************************************************/
477 /*!
478 @brief Causes a blocking delay until a valid touch event occurs
479
480 @note Thanks to 'rossum' and limor for this nifty little tidbit on
481 debouncing the signals via pressure sensitivity (using Z)
482
483 @section Example
484
485 @code
486 #include "drivers/displays/tft/touchscreen.h"
487 ...
488 tsTouchData_t data;
489 tsTouchError_t error;
490
491 while (1)
492 {
493 // Cause a blocking delay until a touch event occurs or 5s passes
494 error = tsWaitForEvent(&data, 5000);
495
496 if (error)
497 {
498 switch(error)
499 {
500 case TS_ERROR_TIMEOUT:
501 printf("Timeout occurred %s", CFG_PRINTF_NEWLINE);
502 break;
503 default:
504 break;
505 }
506 }
507 else
508 {
509 // A valid touch event occurred ... display data
510 printf("Touch Event: X = %04u, Y = %04u %s",
511 data.xlcd,
512 data.ylcd,
513 CFG_PRINTF_NEWLINE);
514 }
515 }
516
517 @endcode
518 */
519 /**************************************************************************/
520 tsTouchError_t tsWaitForEvent(tsTouchData_t* data, uint32_t timeoutMS)
521 {
522 if (!_tsInitialised) tsInit();
523
524 tsRead(data, false);
525
526 // Return the results right away if reading is valid
527 if (data->valid)
528 {
529 return TS_ERROR_NONE;
530 }
531
532 // Handle timeout if delay > 0 milliseconds
533 if (timeoutMS)
534 {
535 uint32_t startTick = systickGetTicks();
536 // Systick rollover may occur while waiting for timeout
537 if (startTick > 0xFFFFFFFF - timeoutMS)
538 {
539 while (data->valid == false)
540 {
541 // Throw alert if timeout delay has been passed
542 if ((systickGetTicks() < startTick) && (systickGetTicks() >= (timeoutMS - (0xFFFFFFFF - startTick))))
543 {
544 return TS_ERROR_TIMEOUT;
545 }
546 tsRead(data, false);
547 }
548 }
549 // No systick rollover will occur ... calculate timeout the simple way
550 else
551 {
552 // Wait in infinite loop
553 while (data->valid == false)
554 {
555 // Throw timeout if delay has been passed
556 if ((systickGetTicks() - startTick) > timeoutMS)
557 {
558 return TS_ERROR_TIMEOUT;
559 }
560 tsRead(data, false);
561 }
562 }
563 }
564 // No timeout requested ... wait forever
565 else
566 {
567 while (data->valid == false)
568 {
569 tsRead(data, false);
570 }
571 }
572
573 // Indicate correct reading
574 return TS_ERROR_NONE;
575 }
576
577 /**************************************************************************/
578 /*!
579 @brief Updates the touch screen threshhold level and saves it
580 to EEPROM
581 */
582 /**************************************************************************/
583 int tsSetThreshhold(uint8_t value)
584 {
585 if ((value < 0) || (value > 254))
586 {
587 return -1;
588 }
589
590 // Update threshhold value
591 _tsThreshhold = value;
592
593 // Persist to EEPROM
594 eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD, value);
595
596 return 0;
597 }
598
599 /**************************************************************************/
600 /*!
601 @brief Gets the current touch screen threshhold level from EEPROM
602 (if present) or returns the default value from projectconfig.h
603 */
604 /**************************************************************************/
605 uint8_t tsGetThreshhold(void)
606 {
607 // Check if custom threshold has been set in eeprom
608 uint8_t thold = eepromReadU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD);
609 if (thold != 0xFF)
610 {
611 // Use value from EEPROM
612 _tsThreshhold = thold;
613 }
614 else
615 {
616 // Use the default value from projectconfig.h
617 _tsThreshhold = CFG_TFTLCD_TS_DEFAULTTHRESHOLD;
618 }
619
620 return _tsThreshhold;
621 }
Unnamed repository; edit this file 'description' to name the repository.
This page took 0.074329 seconds and 5 git commands to generate.