David Smart / RA8875 Featured

Library to control a Graphics TFT connected to 4-wire SPI - revised for the Raio RA8875 Display Controller.

Dependents:   FRDM_RA8875_mPaint RA8875_Demo RA8875_KeyPadDemo SignalGenerator ... more

Fork of SPI_TFT by Peter Drescher

See Components - RA8875 Based Display

Enhanced touch-screen support - where it previous supported both the Resistive Touch and Capacitive Touch based on the FT5206 Touch Controller, now it also has support for the GSL1680 Touch Controller.

Offline Help Manual (Windows chm)

/media/uploads/WiredHome/ra8875.zip.bin (download, rename to .zip and unzip)

RA8875_Touch.cpp@203:704df2dbd3e6, 2020-05-17 (annotated)

Committer:
WiredHome
Date:
Sun May 17 14:07:46 2020 +0000
Revision:
203:704df2dbd3e6
Parent:
202:a22cbc04f332
Child:
205:f215dc32736b
Fix coordinate translation for touch events.; Minor code cleanup.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 78:faf49c381591 1 /// This file contains the RA8875 Touch panel methods.
WiredHome 78:faf49c381591 2 ///
WiredHome 124:1690a7ae871c 3 /// It combines both resistive and capacitive touch methods, and tries
WiredHome 124:1690a7ae871c 4 /// to make them nearly transparent alternates for each other.
WiredHome 124:1690a7ae871c 5 ///
WiredHome 78:faf49c381591 6 #include "RA8875.h"
WiredHome 165:695c24cc5197 7 #include "RA8875_Touch_FT5206.h"
WiredHome 165:695c24cc5197 8 #include "RA8875_Touch_GSL1680.h"
WiredHome 78:faf49c381591 9
WiredHome 83:7bad0068cca0 10 #define NOTOUCH_TIMEOUT_uS 100000
WiredHome 83:7bad0068cca0 11 #define TOUCH_TICKER_uS 1000
WiredHome 83:7bad0068cca0 12
WiredHome 171:f92c0f1f6db4 13 //#define DEBUG "TUCH"
WiredHome 154:ad2450fc3dc3 14 // ...
WiredHome 154:ad2450fc3dc3 15 // INFO("Stuff to show %d", var); // new-line is automatically appended
WiredHome 154:ad2450fc3dc3 16 //
WiredHome 154:ad2450fc3dc3 17 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome 197:853d08e2fb53 18 #define INFO(x, ...) std::printf("[INF %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 197:853d08e2fb53 19 #define WARN(x, ...) std::printf("[WRN %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 197:853d08e2fb53 20 #define ERR(x, ...) std::printf("[ERR %s %4d] " x "\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 154:ad2450fc3dc3 21 static void HexDump(const char * title, const uint8_t * p, int count)
WiredHome 154:ad2450fc3dc3 22 {
WiredHome 154:ad2450fc3dc3 23 int i;
WiredHome 154:ad2450fc3dc3 24 char buf[100] = "0000: ";
WiredHome 154:ad2450fc3dc3 25
WiredHome 154:ad2450fc3dc3 26 if (*title)
WiredHome 154:ad2450fc3dc3 27 INFO("%s", title);
WiredHome 154:ad2450fc3dc3 28 for (i=0; i<count; ) {
WiredHome 154:ad2450fc3dc3 29 sprintf(buf + strlen(buf), "%02X ", *(p+i));
WiredHome 154:ad2450fc3dc3 30 if ((++i & 0x0F) == 0x00) {
WiredHome 154:ad2450fc3dc3 31 INFO("%s", buf);
WiredHome 154:ad2450fc3dc3 32 if (i < count)
WiredHome 154:ad2450fc3dc3 33 sprintf(buf, "%04X: ", i);
WiredHome 154:ad2450fc3dc3 34 else
WiredHome 154:ad2450fc3dc3 35 buf[0] = '\0';
WiredHome 154:ad2450fc3dc3 36 }
WiredHome 154:ad2450fc3dc3 37 }
WiredHome 154:ad2450fc3dc3 38 if (strlen(buf))
WiredHome 154:ad2450fc3dc3 39 INFO("%s", buf);
WiredHome 154:ad2450fc3dc3 40 }
WiredHome 154:ad2450fc3dc3 41 #else
WiredHome 154:ad2450fc3dc3 42 #define INFO(x, ...)
WiredHome 154:ad2450fc3dc3 43 #define WARN(x, ...)
WiredHome 154:ad2450fc3dc3 44 #define ERR(x, ...)
WiredHome 154:ad2450fc3dc3 45 #define HexDump(a, b, c)
WiredHome 154:ad2450fc3dc3 46 #endif
WiredHome 154:ad2450fc3dc3 47
WiredHome 124:1690a7ae871c 48
WiredHome 78:faf49c381591 49 RetCode_t RA8875::TouchPanelInit(void)
WiredHome 78:faf49c381591 50 {
WiredHome 157:1565f38ca44b 51 RetCode_t r = noerror;
WiredHome 190:3132b7dfad82 52
WiredHome 124:1690a7ae871c 53 panelTouched = false;
WiredHome 165:695c24cc5197 54 if (useTouchPanel == TP_GSL1680) {
WiredHome 165:695c24cc5197 55 INFO("TouchPanelInit: TP_GSL1680");
WiredHome 169:1c1a495983bc 56 r = GSL1680_Init();
WiredHome 165:695c24cc5197 57 } else if (useTouchPanel == TP_FT5206) {
WiredHome 124:1690a7ae871c 58 // Set to normal mode
WiredHome 165:695c24cc5197 59 INFO("TouchPanelInit: TP_FT5206");
WiredHome 165:695c24cc5197 60 r = FT5206_Init();
WiredHome 124:1690a7ae871c 61 } else {
WiredHome 155:b3f225ae572c 62 INFO("TouchPanelInit: TP_RES");
WiredHome 197:853d08e2fb53 63 //RA8875_TPCR0: Set enable bit, default sample time, wakeup, and ADC clock
WiredHome 193:74f80834d59d 64 WriteCommand(RA8875_TPCR0, TP_ENABLE | TP_ADC_SAMPLE_DEFAULT_CLKS | TP_ADC_CLKDIV_DEFAULT);
WiredHome 197:853d08e2fb53 65 // RA8875_TPCR1: Set auto/manual, Ref voltage, debounce, manual mode params
WiredHome 193:74f80834d59d 66 WriteCommand(RA8875_TPCR1, TP_MODE_DEFAULT | TP_DEBOUNCE_DEFAULT);
WiredHome 193:74f80834d59d 67 WriteCommand(RA8875_INTC1, ReadCommand(RA8875_INTC1) | RA8875_INT_TP); // reg RA8875_INTC1: Enable Touch Panel Interrupts (D2 = 1)
WiredHome 193:74f80834d59d 68 WriteCommand(RA8875_INTC2, RA8875_INT_TP); // reg RA8875_INTC2: Clear any TP interrupt flag
WiredHome 124:1690a7ae871c 69 touchSample = 0;
WiredHome 124:1690a7ae871c 70 touchState = no_cal;
WiredHome 193:74f80834d59d 71 #if 0
WiredHome 181:0032d1b8f5d4 72 #if (MBED_MAJOR_VERSION >= 5) || (MBED_LIBRARY_VERSION > 127)
WiredHome 145:5eb2492acdda 73 touchTicker.attach_us(callback(this, &RA8875::_TouchTicker), TOUCH_TICKER_uS);
WiredHome 150:35a4db3081c1 74 #else
WiredHome 150:35a4db3081c1 75 touchTicker.attach_us(this, &RA8875::_TouchTicker, TOUCH_TICKER_uS);
WiredHome 150:35a4db3081c1 76 #endif
WiredHome 193:74f80834d59d 77 #endif
WiredHome 165:695c24cc5197 78 timeSinceTouch.start();
WiredHome 165:695c24cc5197 79 timeSinceTouch.reset();
WiredHome 157:1565f38ca44b 80 r = _internal_ts_cal();
WiredHome 83:7bad0068cca0 81 }
WiredHome 157:1565f38ca44b 82 return r;
WiredHome 78:faf49c381591 83 }
WiredHome 78:faf49c381591 84
WiredHome 124:1690a7ae871c 85
WiredHome 124:1690a7ae871c 86 RetCode_t RA8875::TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce, uint8_t bTpManualMode, uint8_t bTpAdcClkDiv, uint8_t bTpAdcSampleTime)
WiredHome 124:1690a7ae871c 87 {
WiredHome 165:695c24cc5197 88 if (useTouchPanel == TP_GSL1680) {
WiredHome 165:695c24cc5197 89 INFO("TouchPanelInit: TP_GSL1680");
WiredHome 165:695c24cc5197 90 } else if (useTouchPanel == TP_FT5206) {
WiredHome 165:695c24cc5197 91 INFO("TouchPanelInit: TP_FT5206");
WiredHome 124:1690a7ae871c 92 TouchPanelInit();
WiredHome 124:1690a7ae871c 93 } else {
WiredHome 155:b3f225ae572c 94 INFO("TouchPanelInit: TP_RES");
WiredHome 124:1690a7ae871c 95 // Parameter bounds check
WiredHome 124:1690a7ae871c 96 if( \
WiredHome 124:1690a7ae871c 97 !(bTpEnable == TP_ENABLE || bTpEnable == TP_ENABLE) || \
WiredHome 124:1690a7ae871c 98 !(bTpAutoManual == TP_MODE_AUTO || bTpAutoManual == TP_MODE_MANUAL) || \
WiredHome 124:1690a7ae871c 99 !(bTpDebounce == TP_DEBOUNCE_OFF || bTpDebounce == TP_DEBOUNCE_ON) || \
WiredHome 124:1690a7ae871c 100 !(bTpManualMode <= TP_MANUAL_LATCH_Y) || \
WiredHome 124:1690a7ae871c 101 !(bTpAdcClkDiv <= TP_ADC_CLKDIV_128) || \
WiredHome 124:1690a7ae871c 102 !(bTpAdcSampleTime <= TP_ADC_SAMPLE_65536_CLKS) \
WiredHome 124:1690a7ae871c 103 ) return bad_parameter;
WiredHome 197:853d08e2fb53 104 // Construct the config byte for RA8875_TPCR0 and write them
WiredHome 193:74f80834d59d 105 WriteCommand(RA8875_TPCR0, bTpEnable | bTpAdcClkDiv | bTpAdcSampleTime); // Note: Wakeup is never enabled
WiredHome 197:853d08e2fb53 106 // Construct the config byte for RA8875_TPCR1 and write them
WiredHome 193:74f80834d59d 107 WriteCommand(RA8875_TPCR1, bTpDebounce | bTpManualMode); // Note: Always uses internal Vref.
WiredHome 124:1690a7ae871c 108 // Set up the interrupt flag and enable bits
WiredHome 193:74f80834d59d 109 WriteCommand(RA8875_INTC1, ReadCommand(RA8875_INTC1) | RA8875_INT_TP); // reg RA8875_INTC1: Enable Touch Panel Interrupts (D2 = 1)
WiredHome 193:74f80834d59d 110 WriteCommand(RA8875_INTC2, RA8875_INT_TP); // reg RA8875_INTC2: Clear any TP interrupt flag
WiredHome 124:1690a7ae871c 111 touchSample = 0;
WiredHome 124:1690a7ae871c 112 touchState = no_cal;
WiredHome 124:1690a7ae871c 113 if (bTpEnable == TP_ENABLE) {
WiredHome 150:35a4db3081c1 114 //touchTicker.attach_us(callback(this, &RA8875::_TouchTicker), TOUCH_TICKER_uS);
WiredHome 181:0032d1b8f5d4 115 #if (MBED_MAJOR_VERSION >= 5) || (MBED_LIBRARY_VERSION > 127)
WiredHome 145:5eb2492acdda 116 touchTicker.attach_us(callback(this, &RA8875::_TouchTicker), TOUCH_TICKER_uS);
WiredHome 150:35a4db3081c1 117 #else
WiredHome 150:35a4db3081c1 118 touchTicker.attach_us(this, &RA8875::_TouchTicker, TOUCH_TICKER_uS);
WiredHome 150:35a4db3081c1 119 #endif
WiredHome 150:35a4db3081c1 120
WiredHome 165:695c24cc5197 121 timeSinceTouch.start();
WiredHome 165:695c24cc5197 122 timeSinceTouch.reset();
WiredHome 124:1690a7ae871c 123 } else {
WiredHome 124:1690a7ae871c 124 touchTicker.detach();
WiredHome 165:695c24cc5197 125 timeSinceTouch.stop();
WiredHome 124:1690a7ae871c 126 }
WiredHome 157:1565f38ca44b 127 _internal_ts_cal();
WiredHome 124:1690a7ae871c 128 }
WiredHome 124:1690a7ae871c 129 return noerror;
WiredHome 124:1690a7ae871c 130 }
WiredHome 124:1690a7ae871c 131
WiredHome 124:1690a7ae871c 132
WiredHome 124:1690a7ae871c 133 int RA8875::TouchChannels(void)
WiredHome 124:1690a7ae871c 134 {
WiredHome 165:695c24cc5197 135 if (useTouchPanel == TP_GSL1680) {
WiredHome 176:4ab96d33a8ec 136 return GSL1680_TOUCH_POINTS; // based on TP_GSL1680 firmware
WiredHome 165:695c24cc5197 137 } else if (useTouchPanel == TP_FT5206) {
WiredHome 176:4ab96d33a8ec 138 return FT5206_TOUCH_POINTS; // based on the FT5206 hardware
WiredHome 124:1690a7ae871c 139 } else if (useTouchPanel == TP_RES) {
WiredHome 176:4ab96d33a8ec 140 return RESISTIVE_TOUCH_POINTS; // based on the RA8875 resistive touch driver
WiredHome 124:1690a7ae871c 141 } else {
WiredHome 124:1690a7ae871c 142 return 0; // it isn't enabled, so there are none.
WiredHome 124:1690a7ae871c 143 }
WiredHome 124:1690a7ae871c 144 }
WiredHome 124:1690a7ae871c 145
WiredHome 124:1690a7ae871c 146
WiredHome 124:1690a7ae871c 147 // +----------------------------------------------------+
WiredHome 124:1690a7ae871c 148 // | |
WiredHome 124:1690a7ae871c 149 // | 1 |
WiredHome 124:1690a7ae871c 150 // | |
WiredHome 124:1690a7ae871c 151 // | |
WiredHome 124:1690a7ae871c 152 // | 2 |
WiredHome 124:1690a7ae871c 153 // | |
WiredHome 124:1690a7ae871c 154 // | |
WiredHome 124:1690a7ae871c 155 // | 3 |
WiredHome 124:1690a7ae871c 156 // | |
WiredHome 124:1690a7ae871c 157 // +----------------------------------------------------+
WiredHome 81:01da2e34283d 158
WiredHome 81:01da2e34283d 159 RetCode_t RA8875::TouchPanelCalibrate(tpMatrix_t * matrix)
WiredHome 81:01da2e34283d 160 {
WiredHome 81:01da2e34283d 161 return TouchPanelCalibrate(NULL, matrix);
WiredHome 81:01da2e34283d 162 }
WiredHome 81:01da2e34283d 163
WiredHome 88:bfddef6ec836 164 RetCode_t RA8875::TouchPanelCalibrate(const char * msg, tpMatrix_t * matrix, int maxwait_s)
WiredHome 81:01da2e34283d 165 {
WiredHome 81:01da2e34283d 166 point_t pTest[3];
WiredHome 81:01da2e34283d 167 point_t pSample[3];
WiredHome 83:7bad0068cca0 168 int x,y;
WiredHome 88:bfddef6ec836 169 Timer timeout; // timeout guards for not-installed, stuck, user not present...
WiredHome 124:1690a7ae871c 170
WiredHome 88:bfddef6ec836 171 timeout.start();
WiredHome 123:2f45e80fec5f 172 while (TouchPanelA2DFiltered(&x, &y) && timeout.read() < maxwait_s) {
WiredHome 197:853d08e2fb53 173 wait_us(20000);
WiredHome 123:2f45e80fec5f 174 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 175 if (external_abort == (*idle_callback)(touchcal_wait, 0)) {
WiredHome 123:2f45e80fec5f 176 return external_abort;
WiredHome 123:2f45e80fec5f 177 }
WiredHome 123:2f45e80fec5f 178 }
WiredHome 123:2f45e80fec5f 179 }
WiredHome 81:01da2e34283d 180 cls();
WiredHome 157:1565f38ca44b 181 if (msg) { // User defines the message
WiredHome 157:1565f38ca44b 182 if (*msg) puts(msg); // If any
WiredHome 157:1565f38ca44b 183 } else { // Default message
WiredHome 157:1565f38ca44b 184 puts("Touch '+' to calibrate the touch panel");
WiredHome 157:1565f38ca44b 185 }
WiredHome 81:01da2e34283d 186 SetTextCursor(0,height()/2);
WiredHome 124:1690a7ae871c 187 pTest[0].x = 50;
WiredHome 124:1690a7ae871c 188 pTest[0].y = 50;
WiredHome 124:1690a7ae871c 189 pTest[1].x = width() - 50;
WiredHome 124:1690a7ae871c 190 pTest[1].y = height()/2;
WiredHome 124:1690a7ae871c 191 pTest[2].x = width()/2;
WiredHome 124:1690a7ae871c 192 pTest[2].y = height() - 50;
WiredHome 88:bfddef6ec836 193
WiredHome 81:01da2e34283d 194 for (int i=0; i<3; i++) {
WiredHome 81:01da2e34283d 195 foreground(Blue);
WiredHome 81:01da2e34283d 196 printf(" (%3d,%3d) => ", pTest[i].x, pTest[i].y);
WiredHome 157:1565f38ca44b 197 fillcircle(pTest[i].x,pTest[i].y, 20, White);
WiredHome 157:1565f38ca44b 198 line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Blue);
WiredHome 157:1565f38ca44b 199 line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Blue);
WiredHome 123:2f45e80fec5f 200 while (!TouchPanelA2DFiltered(&x, &y) && timeout.read() < maxwait_s) {
WiredHome 197:853d08e2fb53 201 wait_us(20000);
WiredHome 123:2f45e80fec5f 202 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 203 if (external_abort == (*idle_callback)(touchcal_wait, 0)) {
WiredHome 123:2f45e80fec5f 204 return external_abort;
WiredHome 123:2f45e80fec5f 205 }
WiredHome 123:2f45e80fec5f 206 }
WiredHome 123:2f45e80fec5f 207 }
WiredHome 81:01da2e34283d 208 pSample[i].x = x;
WiredHome 81:01da2e34283d 209 pSample[i].y = y;
WiredHome 157:1565f38ca44b 210 fillcircle(pTest[i].x,pTest[i].y, 20, Black); // Erase the target
WiredHome 157:1565f38ca44b 211 //line(pTest[i].x-10, pTest[i].y, pTest[i].x+10, pTest[i].y, Black);
WiredHome 157:1565f38ca44b 212 //line(pTest[i].x, pTest[i].y-10, pTest[i].x, pTest[i].y+10, Black);
WiredHome 81:01da2e34283d 213 foreground(Blue);
WiredHome 81:01da2e34283d 214 printf(" (%4d,%4d)\r\n", x,y);
WiredHome 123:2f45e80fec5f 215 while (TouchPanelA2DFiltered(&x, &y) && timeout.read() < maxwait_s) {
WiredHome 197:853d08e2fb53 216 wait_us(20000);
WiredHome 123:2f45e80fec5f 217 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 218 if (external_abort == (*idle_callback)(touchcal_wait, 0)) {
WiredHome 123:2f45e80fec5f 219 return external_abort;
WiredHome 123:2f45e80fec5f 220 }
WiredHome 123:2f45e80fec5f 221 }
WiredHome 123:2f45e80fec5f 222 }
WiredHome 123:2f45e80fec5f 223 for (int t=0; t<100; t++) {
WiredHome 197:853d08e2fb53 224 wait_us(20000);
WiredHome 123:2f45e80fec5f 225 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 226 if (external_abort == (*idle_callback)(touchcal_wait, 0)) {
WiredHome 123:2f45e80fec5f 227 return external_abort;
WiredHome 123:2f45e80fec5f 228 }
WiredHome 123:2f45e80fec5f 229 }
WiredHome 123:2f45e80fec5f 230 }
WiredHome 81:01da2e34283d 231 }
WiredHome 88:bfddef6ec836 232 if (timeout.read() >= maxwait_s)
WiredHome 88:bfddef6ec836 233 return touch_cal_timeout;
WiredHome 88:bfddef6ec836 234 else
WiredHome 88:bfddef6ec836 235 return TouchPanelComputeCalibration(pTest, pSample, matrix);
WiredHome 81:01da2e34283d 236 }
WiredHome 81:01da2e34283d 237
WiredHome 81:01da2e34283d 238
WiredHome 81:01da2e34283d 239 /**********************************************************************
WiredHome 81:01da2e34283d 240 *
WiredHome 123:2f45e80fec5f 241 * Function: TouchPanelReadable()
WiredHome 81:01da2e34283d 242 *
WiredHome 81:01da2e34283d 243 */
WiredHome 83:7bad0068cca0 244 TouchCode_t RA8875::TouchPanelReadable(point_t * TouchPoint)
WiredHome 81:01da2e34283d 245 {
WiredHome 124:1690a7ae871c 246 TouchCode_t ts = no_touch;
WiredHome 124:1690a7ae871c 247
WiredHome 165:695c24cc5197 248 if (useTouchPanel == TP_FT5206) {
WiredHome 198:9b6851107426 249 //INFO("TP_FT5206");
WiredHome 165:695c24cc5197 250 } else if (useTouchPanel == TP_GSL1680) {
WiredHome 198:9b6851107426 251 //INFO("TP_GSL1680");
WiredHome 165:695c24cc5197 252 } else if (useTouchPanel == TP_RES) {
WiredHome 198:9b6851107426 253 ReadResistive();
WiredHome 124:1690a7ae871c 254 }
WiredHome 165:695c24cc5197 255 // For Resistive touch, panelTouched is computed above.
WiredHome 165:695c24cc5197 256 // For Cap Sense, panelTouched is set in another process
WiredHome 124:1690a7ae871c 257 if (panelTouched == true) {
WiredHome 124:1690a7ae871c 258 panelTouched = false;
WiredHome 124:1690a7ae871c 259 if (TouchPoint) {
WiredHome 202:a22cbc04f332 260 *TouchPoint = touchInfo[0].coordinates;
WiredHome 124:1690a7ae871c 261 ts = touchInfo[0].touchCode;
WiredHome 193:74f80834d59d 262 #ifdef DEBUG
WiredHome 193:74f80834d59d 263 static TouchCode_t lastTS = no_touch;
WiredHome 193:74f80834d59d 264 if (lastTS != ts)
WiredHome 197:853d08e2fb53 265 INFO("Touch[0] %2d (%4d,%4d)", touchInfo[0].touchCode,
WiredHome 197:853d08e2fb53 266 touchInfo[0].coordinates.x, touchInfo[0].coordinates.y);
WiredHome 193:74f80834d59d 267 lastTS = ts;
WiredHome 193:74f80834d59d 268 #endif
WiredHome 130:d633e80840e0 269 } else {
WiredHome 130:d633e80840e0 270 ts = touch;
WiredHome 124:1690a7ae871c 271 }
WiredHome 81:01da2e34283d 272 }
WiredHome 83:7bad0068cca0 273 return ts;
WiredHome 81:01da2e34283d 274 }
WiredHome 81:01da2e34283d 275
WiredHome 190:3132b7dfad82 276 uint8_t RA8875::TouchID(uint8_t channel)
WiredHome 166:53fd4a876dac 277 {
WiredHome 166:53fd4a876dac 278 if (channel >= TouchChannels())
WiredHome 166:53fd4a876dac 279 channel = 0;
WiredHome 190:3132b7dfad82 280 return touchInfo[channel].touchID;
WiredHome 166:53fd4a876dac 281 }
WiredHome 166:53fd4a876dac 282
WiredHome 190:3132b7dfad82 283 TouchCode_t RA8875::TouchCode(uint8_t channel)
WiredHome 190:3132b7dfad82 284 {
WiredHome 166:53fd4a876dac 285 if (channel >= TouchChannels())
WiredHome 166:53fd4a876dac 286 channel = 0;
WiredHome 181:0032d1b8f5d4 287 INFO("TouchCode[%d] = %d", channel, touchInfo[channel].touchCode);
WiredHome 181:0032d1b8f5d4 288 return touchInfo[channel].touchCode;
WiredHome 166:53fd4a876dac 289 }
WiredHome 166:53fd4a876dac 290
WiredHome 166:53fd4a876dac 291 point_t RA8875::TouchCoordinates(uint8_t channel)
WiredHome 166:53fd4a876dac 292 {
WiredHome 166:53fd4a876dac 293 if (channel >= TouchChannels())
WiredHome 166:53fd4a876dac 294 channel = 0;
WiredHome 203:704df2dbd3e6 295 return touchInfo[channel].coordinates;
WiredHome 166:53fd4a876dac 296 }
WiredHome 81:01da2e34283d 297
WiredHome 85:022bba13c5c4 298 TouchCode_t RA8875::TouchPanelGet(point_t * TouchPoint)
WiredHome 85:022bba13c5c4 299 {
WiredHome 123:2f45e80fec5f 300 TouchCode_t t = no_touch;
WiredHome 124:1690a7ae871c 301
WiredHome 123:2f45e80fec5f 302 while (true) {
WiredHome 85:022bba13c5c4 303 t = TouchPanelReadable(TouchPoint);
WiredHome 123:2f45e80fec5f 304 if (t != no_touch)
WiredHome 123:2f45e80fec5f 305 break;
WiredHome 123:2f45e80fec5f 306 if (idle_callback) {
WiredHome 149:c62c4b2d6a15 307 if (external_abort == (*idle_callback)(touch_wait, 0)) {
WiredHome 123:2f45e80fec5f 308 return no_touch;
WiredHome 123:2f45e80fec5f 309 }
WiredHome 123:2f45e80fec5f 310 }
WiredHome 123:2f45e80fec5f 311 }
WiredHome 85:022bba13c5c4 312 return t;
WiredHome 85:022bba13c5c4 313 }
WiredHome 85:022bba13c5c4 314
WiredHome 123:2f45e80fec5f 315 // Below here are primarily "helper" functions. While many are accessible
WiredHome 123:2f45e80fec5f 316 // to the user code, they usually don't need to be called.
WiredHome 123:2f45e80fec5f 317
WiredHome 81:01da2e34283d 318 RetCode_t RA8875::TouchPanelSetMatrix(tpMatrix_t * matrixPtr)
WiredHome 81:01da2e34283d 319 {
WiredHome 81:01da2e34283d 320 if (matrixPtr == NULL || matrixPtr->Divider == 0)
WiredHome 81:01da2e34283d 321 return bad_parameter;
WiredHome 81:01da2e34283d 322 memcpy(&tpMatrix, matrixPtr, sizeof(tpMatrix_t));
WiredHome 83:7bad0068cca0 323 touchState = no_touch;
WiredHome 81:01da2e34283d 324 return noerror;
WiredHome 81:01da2e34283d 325 }
WiredHome 81:01da2e34283d 326
WiredHome 157:1565f38ca44b 327 const tpMatrix_t * RA8875::TouchPanelGetMatrix()
WiredHome 157:1565f38ca44b 328 {
WiredHome 157:1565f38ca44b 329 return &tpMatrix;
WiredHome 157:1565f38ca44b 330 }
WiredHome 157:1565f38ca44b 331
WiredHome 157:1565f38ca44b 332
WiredHome 83:7bad0068cca0 333 static void InsertionSort(int * buf, int bufsize)
WiredHome 83:7bad0068cca0 334 {
WiredHome 83:7bad0068cca0 335 int i, j;
WiredHome 83:7bad0068cca0 336 int temp;
WiredHome 124:1690a7ae871c 337
WiredHome 108:7415c405ee08 338 for(i = 1; i < bufsize; i++) {
WiredHome 83:7bad0068cca0 339 temp = buf[i];
WiredHome 83:7bad0068cca0 340 j = i;
WiredHome 83:7bad0068cca0 341 while( j && (buf[j-1] > temp) ) {
WiredHome 83:7bad0068cca0 342 buf[j] = buf[j-1];
WiredHome 83:7bad0068cca0 343 j = j-1;
WiredHome 83:7bad0068cca0 344 }
WiredHome 83:7bad0068cca0 345 buf[j] = temp;
WiredHome 83:7bad0068cca0 346 } // End of sort
WiredHome 83:7bad0068cca0 347 }
WiredHome 83:7bad0068cca0 348
WiredHome 83:7bad0068cca0 349
WiredHome 83:7bad0068cca0 350 void RA8875::_TouchTicker(void)
WiredHome 78:faf49c381591 351 {
WiredHome 197:853d08e2fb53 352 //INFO("_TouchTicker()");
WiredHome 165:695c24cc5197 353 if (timeSinceTouch.read_us() > NOTOUCH_TIMEOUT_uS) {
WiredHome 83:7bad0068cca0 354 touchSample = 0;
WiredHome 193:74f80834d59d 355 if (touchState == held) {
WiredHome 83:7bad0068cca0 356 touchState = release;
WiredHome 193:74f80834d59d 357 INFO("release %d", touchState);
WiredHome 193:74f80834d59d 358 } else {
WiredHome 193:74f80834d59d 359 INFO("!= held %d", touchState);
WiredHome 83:7bad0068cca0 360 touchState = no_touch;
WiredHome 193:74f80834d59d 361 }
WiredHome 165:695c24cc5197 362 timeSinceTouch.reset();
WiredHome 83:7bad0068cca0 363 }
WiredHome 83:7bad0068cca0 364 }
WiredHome 83:7bad0068cca0 365
WiredHome 198:9b6851107426 366
WiredHome 198:9b6851107426 367 // Description: Given a valid set of calibration factors and a point
WiredHome 198:9b6851107426 368 // value reported by the touch screen, this function
WiredHome 198:9b6851107426 369 // calculates and returns the true (or closest to true)
WiredHome 198:9b6851107426 370 // display point below the spot where the touch screen
WiredHome 198:9b6851107426 371 // was touched.
WiredHome 198:9b6851107426 372 //
WiredHome 198:9b6851107426 373 // Argument(s): displayPtr (output) - Pointer to the calculated
WiredHome 198:9b6851107426 374 // (true) display point.
WiredHome 198:9b6851107426 375 // screenPtr (input) - Pointer to the reported touch
WiredHome 198:9b6851107426 376 // screen point.
WiredHome 198:9b6851107426 377 // matrixPtr (input) - Pointer to calibration factors
WiredHome 198:9b6851107426 378 // matrix previously calculated
WiredHome 198:9b6851107426 379 // from a call to
WiredHome 198:9b6851107426 380 // setCalibrationMatrix()
WiredHome 198:9b6851107426 381 //
WiredHome 198:9b6851107426 382 // The function simply solves for Xd and Yd by implementing the
WiredHome 198:9b6851107426 383 // computations required by the translation matrix.
WiredHome 198:9b6851107426 384 //
WiredHome 198:9b6851107426 385 // /- -\ //
WiredHome 198:9b6851107426 386 // /- -\ /- -\ | | //
WiredHome 198:9b6851107426 387 // | | | | | Xs | //
WiredHome 198:9b6851107426 388 // | Xd | | A B C | | | //
WiredHome 198:9b6851107426 389 // | | = | | * | Ys | //
WiredHome 198:9b6851107426 390 // | Yd | | D E F | | | //
WiredHome 198:9b6851107426 391 // | | | | | 1 | //
WiredHome 198:9b6851107426 392 // \- -/ \- -/ | | //
WiredHome 198:9b6851107426 393 // \- -/ //
WiredHome 198:9b6851107426 394 //
WiredHome 198:9b6851107426 395 // It must be kept brief to avoid consuming CPU cycles.
WiredHome 198:9b6851107426 396 //
WiredHome 198:9b6851107426 397 // Return: OK - the display point was correctly calculated
WiredHome 198:9b6851107426 398 // and its value is in the output argument.
WiredHome 198:9b6851107426 399 // NOT_OK - an error was detected and the function
WiredHome 198:9b6851107426 400 // failed to return a valid point.
WiredHome 198:9b6851107426 401 //
WiredHome 198:9b6851107426 402 // NOTE! NOTE! NOTE!
WiredHome 198:9b6851107426 403 //
WiredHome 198:9b6851107426 404 // setCalibrationMatrix() and getDisplayPoint() will do fine
WiredHome 198:9b6851107426 405 // for you as they are, provided that your digitizer
WiredHome 198:9b6851107426 406 // resolution does not exceed 10 bits (1024 values). Higher
WiredHome 198:9b6851107426 407 // resolutions may cause the integer operations to overflow
WiredHome 198:9b6851107426 408 // and return incorrect values. If you wish to use these
WiredHome 198:9b6851107426 409 // functions with digitizer resolutions of 12 bits (4096
WiredHome 198:9b6851107426 410 // values) you will either have to a) use 64-bit signed
WiredHome 198:9b6851107426 411 // integer variables and math, or b) judiciously modify the
WiredHome 198:9b6851107426 412 // operations to scale results by a factor of 2 or even 4.
WiredHome 198:9b6851107426 413 //
WiredHome 198:9b6851107426 414 void RA8875::ReadResistive() {
WiredHome 198:9b6851107426 415 TouchCode_t ts = no_touch;
WiredHome 198:9b6851107426 416 int a2dX = 0;
WiredHome 198:9b6851107426 417 int a2dY = 0;
WiredHome 198:9b6851107426 418
WiredHome 198:9b6851107426 419 touchInfo[0].touchID = 0;
WiredHome 198:9b6851107426 420 ts = TouchPanelA2DFiltered(&a2dX, &a2dY);
WiredHome 198:9b6851107426 421 if (ts != no_touch) {
WiredHome 198:9b6851107426 422 panelTouched = true;
WiredHome 198:9b6851107426 423 numberOfTouchPoints = 1;
WiredHome 198:9b6851107426 424
WiredHome 198:9b6851107426 425 if (tpMatrix.Divider != 0) {
WiredHome 198:9b6851107426 426 /* Operation order is important since we are doing integer */
WiredHome 198:9b6851107426 427 /* math. Make sure you add all terms together before */
WiredHome 198:9b6851107426 428 /* dividing, so that the remainder is not rounded off */
WiredHome 198:9b6851107426 429 /* prematurely. */
WiredHome 202:a22cbc04f332 430 touchInfo[0].coordinates = TranslateOrientation(
WiredHome 202:a22cbc04f332 431 ((tpMatrix.An * a2dX) + (tpMatrix.Bn * a2dY) + tpMatrix.Cn) / tpMatrix.Divider,
WiredHome 202:a22cbc04f332 432 ((tpMatrix.Dn * a2dX) + (tpMatrix.En * a2dY) + tpMatrix.Fn) / tpMatrix.Divider );
WiredHome 198:9b6851107426 433 } else {
WiredHome 198:9b6851107426 434 ts = no_cal;
WiredHome 198:9b6851107426 435 }
WiredHome 198:9b6851107426 436 } else {
WiredHome 198:9b6851107426 437 numberOfTouchPoints = 0;
WiredHome 198:9b6851107426 438 }
WiredHome 198:9b6851107426 439 touchInfo[0].touchCode = ts;
WiredHome 198:9b6851107426 440 }
WiredHome 198:9b6851107426 441
WiredHome 198:9b6851107426 442
WiredHome 83:7bad0068cca0 443 TouchCode_t RA8875::TouchPanelA2DRaw(int *x, int *y)
WiredHome 83:7bad0068cca0 444 {
WiredHome 154:ad2450fc3dc3 445 INFO("A2Raw");
WiredHome 193:74f80834d59d 446 if( (ReadCommand(RA8875_INTC2) & RA8875_INT_TP) ) { // Test for TP Interrupt pending in register RA8875_INTC2
WiredHome 154:ad2450fc3dc3 447 INFO("Int pending");
WiredHome 165:695c24cc5197 448 timeSinceTouch.reset();
WiredHome 193:74f80834d59d 449 *y = ReadCommand(RA8875_TPYH) << 2 | ( (ReadCommand(RA8875_TPXYL) & 0xC) >> 2 ); // D[9:2] from reg RA8875_TPYH, D[1:0] from reg RA8875_TPXYL[3:2]
WiredHome 193:74f80834d59d 450 *x = ReadCommand(RA8875_TPXH) << 2 | ( (ReadCommand(RA8875_TPXYL) & 0x3) ); // D[9:2] from reg RA8875_TPXH, D[1:0] from reg RA8875_TPXYL[1:0]
WiredHome 193:74f80834d59d 451 INFO("(x,y) = (%d,%d)", *x, *y);
WiredHome 193:74f80834d59d 452 WriteCommand(RA8875_INTC2, RA8875_INT_TP); // reg RA8875_INTC2: Clear that TP interrupt flag
WiredHome 83:7bad0068cca0 453 touchState = touch;
WiredHome 193:74f80834d59d 454 } else if (ReadCommand(RA8875_TPXYL) & RA8875_TPXYL_ADET) {
WiredHome 193:74f80834d59d 455 INFO("held");
WiredHome 193:74f80834d59d 456 touchState = held;
WiredHome 83:7bad0068cca0 457 } else {
WiredHome 154:ad2450fc3dc3 458 INFO("no touch");
WiredHome 83:7bad0068cca0 459 touchState = no_touch;
WiredHome 83:7bad0068cca0 460 }
WiredHome 83:7bad0068cca0 461 return touchState;
WiredHome 83:7bad0068cca0 462 }
WiredHome 83:7bad0068cca0 463
WiredHome 83:7bad0068cca0 464 TouchCode_t RA8875::TouchPanelA2DFiltered(int *x, int *y)
WiredHome 83:7bad0068cca0 465 {
WiredHome 83:7bad0068cca0 466 static int xbuf[TPBUFSIZE], ybuf[TPBUFSIZE];
WiredHome 83:7bad0068cca0 467 static int lastX, lastY;
WiredHome 83:7bad0068cca0 468 int i, j;
WiredHome 83:7bad0068cca0 469 TouchCode_t ret = touchState;
WiredHome 78:faf49c381591 470
WiredHome 193:74f80834d59d 471 if ( (ReadCommand(RA8875_INTC2) & RA8875_INT_TP) ) { // Test for TP Interrupt pending in register RA8875_INTC2
WiredHome 165:695c24cc5197 472 timeSinceTouch.reset();
WiredHome 78:faf49c381591 473 // Get the next data samples
WiredHome 193:74f80834d59d 474 ybuf[touchSample] = ReadCommand(RA8875_TPYH) << 2 | ( (ReadCommand(RA8875_TPXYL) & 0xC) >> 2 ); // D[9:2] from reg RA8875_TPYH, D[1:0] from reg RA8875_TPXYL[3:2]
WiredHome 193:74f80834d59d 475 xbuf[touchSample] = ReadCommand(RA8875_TPXH) << 2 | ( (ReadCommand(RA8875_TPXYL) & 0x3) ); // D[9:2] from reg RA8875_TPXH, D[1:0] from reg RA8875_TPXYL[1:0]
WiredHome 78:faf49c381591 476 // Check for a complete set
WiredHome 197:853d08e2fb53 477 if (++touchSample == TPBUFSIZE) {
WiredHome 78:faf49c381591 478 // Buffers are full, so process them using Finn's method described in Analog Dialogue No. 44, Feb 2010
WiredHome 78:faf49c381591 479 // This requires sorting the samples in order of size, then discarding the top 25% and
WiredHome 78:faf49c381591 480 // bottom 25% as noise spikes. Finally, the middle 50% of the values are averaged to
WiredHome 78:faf49c381591 481 // reduce Gaussian noise.
WiredHome 83:7bad0068cca0 482 InsertionSort(ybuf, TPBUFSIZE);
WiredHome 83:7bad0068cca0 483 InsertionSort(xbuf, TPBUFSIZE);
WiredHome 78:faf49c381591 484 // Average the middle half of the Y values and report them
WiredHome 78:faf49c381591 485 j = 0;
WiredHome 197:853d08e2fb53 486 for (i = (TPBUFSIZE/4) - 1; i < TPBUFSIZE - TPBUFSIZE/4; i++ ) {
WiredHome 78:faf49c381591 487 j += ybuf[i];
WiredHome 78:faf49c381591 488 }
WiredHome 83:7bad0068cca0 489 *y = lastY = j * (float)2/TPBUFSIZE; // This is the average
WiredHome 78:faf49c381591 490 // Average the middle half of the X values and report them
WiredHome 78:faf49c381591 491 j = 0;
WiredHome 78:faf49c381591 492 for(i = (TPBUFSIZE/4) - 1; i < TPBUFSIZE - TPBUFSIZE/4; i++ ) {
WiredHome 78:faf49c381591 493 j += xbuf[i];
WiredHome 78:faf49c381591 494 }
WiredHome 83:7bad0068cca0 495 *x = lastX = j * (float)2/TPBUFSIZE; // This is the average
WiredHome 78:faf49c381591 496 // Tidy up and return
WiredHome 193:74f80834d59d 497 if (touchState == touch || touchState == held) {
WiredHome 83:7bad0068cca0 498 touchState = held;
WiredHome 197:853d08e2fb53 499 //INFO("held");
WiredHome 193:74f80834d59d 500 } else {
WiredHome 83:7bad0068cca0 501 touchState = touch;
WiredHome 197:853d08e2fb53 502 //INFO("touch");
WiredHome 193:74f80834d59d 503 }
WiredHome 83:7bad0068cca0 504 ret = touchState;
WiredHome 83:7bad0068cca0 505 touchSample = 0; // Ready to start on the next set of data samples
WiredHome 78:faf49c381591 506 } else {
WiredHome 78:faf49c381591 507 // Buffer not yet full, so do not return any results yet
WiredHome 83:7bad0068cca0 508 if (touchState == touch || touchState == held) {
WiredHome 83:7bad0068cca0 509 *x = lastX;
WiredHome 83:7bad0068cca0 510 *y = lastY;
WiredHome 197:853d08e2fb53 511 #ifdef DEBUG
WiredHome 193:74f80834d59d 512 {
WiredHome 193:74f80834d59d 513 static TouchCode_t lastTC = no_touch;
WiredHome 193:74f80834d59d 514 if (lastTC != touchState)
WiredHome 197:853d08e2fb53 515 //INFO("held");
WiredHome 193:74f80834d59d 516 lastTC = touchState;
WiredHome 193:74f80834d59d 517 }
WiredHome 197:853d08e2fb53 518 #endif
WiredHome 83:7bad0068cca0 519 ret = touchState = held;
WiredHome 193:74f80834d59d 520 } else {
WiredHome 193:74f80834d59d 521 INFO("else %d, %d", touchState, touchSample);
WiredHome 83:7bad0068cca0 522 }
WiredHome 78:faf49c381591 523 }
WiredHome 193:74f80834d59d 524 WriteCommand(RA8875_INTC2, RA8875_INT_TP); // reg RA8875_INTC2: Clear that TP interrupt flag
WiredHome 193:74f80834d59d 525 } else if (0 == (ReadCommand(RA8875_TPXYL) & RA8875_TPXYL_ADET)) {
WiredHome 193:74f80834d59d 526 INFO("held");
WiredHome 193:74f80834d59d 527 *x = lastX;
WiredHome 193:74f80834d59d 528 *y = lastY;
WiredHome 193:74f80834d59d 529 ret = touchState = held;
WiredHome 193:74f80834d59d 530 } else if (timeSinceTouch.read_ms() < 20) {
WiredHome 193:74f80834d59d 531 *x = lastX;
WiredHome 193:74f80834d59d 532 *y = lastY;
WiredHome 193:74f80834d59d 533 //ret = touchState;
WiredHome 193:74f80834d59d 534 } else {
WiredHome 193:74f80834d59d 535 //INFO("touchState %d", touchState);
WiredHome 193:74f80834d59d 536 //touchSample = 0;
WiredHome 193:74f80834d59d 537 *x = lastX;
WiredHome 193:74f80834d59d 538 *y = lastY;
WiredHome 193:74f80834d59d 539 if (touchState == no_touch || touchState == release) {
WiredHome 193:74f80834d59d 540 ret = touchState = no_touch;
WiredHome 193:74f80834d59d 541 } else {
WiredHome 193:74f80834d59d 542 INFO("release");
WiredHome 193:74f80834d59d 543 touchSample = 0;
WiredHome 193:74f80834d59d 544 touchState = no_touch;
WiredHome 193:74f80834d59d 545 ret = release;
WiredHome 193:74f80834d59d 546 }
WiredHome 193:74f80834d59d 547 #if 0
WiredHome 83:7bad0068cca0 548 if (touchState == touch || touchState == held) {
WiredHome 83:7bad0068cca0 549 *x = lastX;
WiredHome 83:7bad0068cca0 550 *y = lastY;
WiredHome 83:7bad0068cca0 551 ret = touchState = held;
WiredHome 193:74f80834d59d 552 INFO("held");
WiredHome 83:7bad0068cca0 553 } else if (touchState == release) {
WiredHome 83:7bad0068cca0 554 *x = lastX;
WiredHome 83:7bad0068cca0 555 *y = lastY;
WiredHome 83:7bad0068cca0 556 ret = release;
WiredHome 83:7bad0068cca0 557 touchState = no_touch;
WiredHome 193:74f80834d59d 558 INFO("release");
WiredHome 83:7bad0068cca0 559 }
WiredHome 193:74f80834d59d 560 #endif
WiredHome 83:7bad0068cca0 561 }
WiredHome 83:7bad0068cca0 562 return ret;
WiredHome 78:faf49c381591 563 }
WiredHome 78:faf49c381591 564
WiredHome 167:8aa3fb2a5a31 565 /// The following section is derived from Carlos E. Vidales.
WiredHome 167:8aa3fb2a5a31 566 ///
WiredHome 167:8aa3fb2a5a31 567 /// @copyright &copy; 2001, Carlos E. Vidales. All rights reserved.
WiredHome 167:8aa3fb2a5a31 568 ///
WiredHome 167:8aa3fb2a5a31 569 /// This sample program was written and put in the public domain
WiredHome 167:8aa3fb2a5a31 570 /// by Carlos E. Vidales. The program is provided "as is"
WiredHome 167:8aa3fb2a5a31 571 /// without warranty of any kind, either expressed or implied.
WiredHome 167:8aa3fb2a5a31 572 /// If you choose to use the program within your own products
WiredHome 167:8aa3fb2a5a31 573 /// you do so at your own risk, and assume the responsibility
WiredHome 167:8aa3fb2a5a31 574 /// for servicing, repairing or correcting the program should
WiredHome 167:8aa3fb2a5a31 575 /// it prove defective in any manner.
WiredHome 167:8aa3fb2a5a31 576 /// You may copy and distribute the program's source code in any
WiredHome 167:8aa3fb2a5a31 577 /// medium, provided that you also include in each copy an
WiredHome 167:8aa3fb2a5a31 578 /// appropriate copyright notice and disclaimer of warranty.
WiredHome 167:8aa3fb2a5a31 579 /// You may also modify this program and distribute copies of
WiredHome 167:8aa3fb2a5a31 580 /// it provided that you include prominent notices stating
WiredHome 167:8aa3fb2a5a31 581 /// that you changed the file(s) and the date of any change,
WiredHome 167:8aa3fb2a5a31 582 /// and that you do not charge any royalties or licenses for
WiredHome 167:8aa3fb2a5a31 583 /// its use.
WiredHome 167:8aa3fb2a5a31 584 ///
WiredHome 167:8aa3fb2a5a31 585 /// This file contains functions that implement calculations
WiredHome 167:8aa3fb2a5a31 586 /// necessary to obtain calibration factors for a touch screen
WiredHome 167:8aa3fb2a5a31 587 /// that suffers from multiple distortion effects: namely,
WiredHome 167:8aa3fb2a5a31 588 /// translation, scaling and rotation.
WiredHome 167:8aa3fb2a5a31 589 ///
WiredHome 167:8aa3fb2a5a31 590 /// The following set of equations represent a valid display
WiredHome 167:8aa3fb2a5a31 591 /// point given a corresponding set of touch screen points:
WiredHome 167:8aa3fb2a5a31 592 ///
WiredHome 167:8aa3fb2a5a31 593 /// <pre>
WiredHome 190:3132b7dfad82 594 /// /- -\ //
WiredHome 190:3132b7dfad82 595 /// /- -\ /- -\ | | //
WiredHome 190:3132b7dfad82 596 /// | | | | | Xs | //
WiredHome 190:3132b7dfad82 597 /// | Xd | | A B C | | | //
WiredHome 190:3132b7dfad82 598 /// | | = | | * | Ys | //
WiredHome 190:3132b7dfad82 599 /// | Yd | | D E F | | | //
WiredHome 190:3132b7dfad82 600 /// | | | | | 1 | //
WiredHome 190:3132b7dfad82 601 /// \- -/ \- -/ | | //
WiredHome 190:3132b7dfad82 602 /// \- -/ //
WiredHome 167:8aa3fb2a5a31 603 /// where:
WiredHome 167:8aa3fb2a5a31 604 /// (Xd,Yd) represents the desired display point
WiredHome 167:8aa3fb2a5a31 605 /// coordinates,
WiredHome 167:8aa3fb2a5a31 606 /// (Xs,Ys) represents the available touch screen
WiredHome 167:8aa3fb2a5a31 607 /// coordinates, and the matrix
WiredHome 190:3132b7dfad82 608 /// /- -\ represents the factors used to translate
WiredHome 190:3132b7dfad82 609 /// |A,B,C| the available touch screen point values
WiredHome 190:3132b7dfad82 610 /// |D,E,F| into the corresponding display
WiredHome 190:3132b7dfad82 611 /// \- -/ coordinates.
WiredHome 190:3132b7dfad82 612 ///
WiredHome 167:8aa3fb2a5a31 613 /// Note that for practical considerations, the utilities
WiredHome 167:8aa3fb2a5a31 614 /// within this file do not use the matrix coefficients as
WiredHome 167:8aa3fb2a5a31 615 /// defined above, but instead use the following
WiredHome 167:8aa3fb2a5a31 616 /// equivalents, since floating point math is not used:
WiredHome 167:8aa3fb2a5a31 617 /// A = An/Divider
WiredHome 167:8aa3fb2a5a31 618 /// B = Bn/Divider
WiredHome 167:8aa3fb2a5a31 619 /// C = Cn/Divider
WiredHome 167:8aa3fb2a5a31 620 /// D = Dn/Divider
WiredHome 167:8aa3fb2a5a31 621 /// E = En/Divider
WiredHome 167:8aa3fb2a5a31 622 /// F = Fn/Divider
WiredHome 167:8aa3fb2a5a31 623 /// The functions provided within this file are:
WiredHome 167:8aa3fb2a5a31 624 /// setCalibrationMatrix() - calculates the set of factors
WiredHome 167:8aa3fb2a5a31 625 /// in the above equation, given
WiredHome 167:8aa3fb2a5a31 626 /// three sets of test points.
WiredHome 167:8aa3fb2a5a31 627 /// getDisplayPoint() - returns the actual display
WiredHome 167:8aa3fb2a5a31 628 /// coordinates, given a set of
WiredHome 167:8aa3fb2a5a31 629 /// touch screen coordinates.
WiredHome 167:8aa3fb2a5a31 630 /// translateRawScreenCoordinates() - helper function to transform
WiredHome 167:8aa3fb2a5a31 631 /// raw screen points into values
WiredHome 167:8aa3fb2a5a31 632 /// scaled to the desired display
WiredHome 167:8aa3fb2a5a31 633 /// resolution.
WiredHome 167:8aa3fb2a5a31 634 ///
WiredHome 167:8aa3fb2a5a31 635 ///
WiredHome 167:8aa3fb2a5a31 636 /// Function: setCalibrationMatrix()
WiredHome 167:8aa3fb2a5a31 637 ///
WiredHome 167:8aa3fb2a5a31 638 /// Description: Calling this function with valid input data
WiredHome 167:8aa3fb2a5a31 639 /// in the display and screen input arguments
WiredHome 167:8aa3fb2a5a31 640 /// causes the calibration factors between the
WiredHome 167:8aa3fb2a5a31 641 /// screen and display points to be calculated,
WiredHome 167:8aa3fb2a5a31 642 /// and the output argument - matrixPtr - to be
WiredHome 167:8aa3fb2a5a31 643 /// populated.
WiredHome 167:8aa3fb2a5a31 644 ///
WiredHome 167:8aa3fb2a5a31 645 /// This function needs to be called only when new
WiredHome 167:8aa3fb2a5a31 646 /// calibration factors are desired.
WiredHome 167:8aa3fb2a5a31 647 ///
WiredHome 167:8aa3fb2a5a31 648 ///
WiredHome 167:8aa3fb2a5a31 649 /// Argument(s): displayPtr (input) - Pointer to an array of three
WiredHome 167:8aa3fb2a5a31 650 /// sample, reference points.
WiredHome 167:8aa3fb2a5a31 651 /// screenPtr (input) - Pointer to the array of touch
WiredHome 167:8aa3fb2a5a31 652 /// screen points corresponding
WiredHome 167:8aa3fb2a5a31 653 /// to the reference display points.
WiredHome 167:8aa3fb2a5a31 654 /// matrixPtr (output) - Pointer to the calibration
WiredHome 167:8aa3fb2a5a31 655 /// matrix computed for the set
WiredHome 167:8aa3fb2a5a31 656 /// of points being provided.
WiredHome 167:8aa3fb2a5a31 657 ///
WiredHome 167:8aa3fb2a5a31 658 ///
WiredHome 167:8aa3fb2a5a31 659 /// From the article text, recall that the matrix coefficients are
WiredHome 167:8aa3fb2a5a31 660 /// resolved to be the following:
WiredHome 167:8aa3fb2a5a31 661 ///
WiredHome 167:8aa3fb2a5a31 662 ///
WiredHome 167:8aa3fb2a5a31 663 /// Divider = (Xs0 - Xs2)*(Ys1 - Ys2) - (Xs1 - Xs2)*(Ys0 - Ys2)
WiredHome 167:8aa3fb2a5a31 664 ///
WiredHome 167:8aa3fb2a5a31 665 ///
WiredHome 167:8aa3fb2a5a31 666 ///
WiredHome 167:8aa3fb2a5a31 667 /// (Xd0 - Xd2)*(Ys1 - Ys2) - (Xd1 - Xd2)*(Ys0 - Ys2)
WiredHome 167:8aa3fb2a5a31 668 /// A = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 669 /// Divider
WiredHome 167:8aa3fb2a5a31 670 ///
WiredHome 167:8aa3fb2a5a31 671 ///
WiredHome 167:8aa3fb2a5a31 672 /// (Xs0 - Xs2)*(Xd1 - Xd2) - (Xd0 - Xd2)*(Xs1 - Xs2)
WiredHome 167:8aa3fb2a5a31 673 /// B = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 674 /// Divider
WiredHome 167:8aa3fb2a5a31 675 ///
WiredHome 167:8aa3fb2a5a31 676 ///
WiredHome 167:8aa3fb2a5a31 677 /// Ys0*(Xs2*Xd1 - Xs1*Xd2) +
WiredHome 167:8aa3fb2a5a31 678 /// Ys1*(Xs0*Xd2 - Xs2*Xd0) +
WiredHome 167:8aa3fb2a5a31 679 /// Ys2*(Xs1*Xd0 - Xs0*Xd1)
WiredHome 167:8aa3fb2a5a31 680 /// C = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 681 /// Divider
WiredHome 167:8aa3fb2a5a31 682 ///
WiredHome 167:8aa3fb2a5a31 683 ///
WiredHome 167:8aa3fb2a5a31 684 /// (Yd0 - Yd2)*(Ys1 - Ys2) - (Yd1 - Yd2)*(Ys0 - Ys2)
WiredHome 167:8aa3fb2a5a31 685 /// D = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 686 /// Divider
WiredHome 167:8aa3fb2a5a31 687 ///
WiredHome 167:8aa3fb2a5a31 688 ///
WiredHome 167:8aa3fb2a5a31 689 /// (Xs0 - Xs2)*(Yd1 - Yd2) - (Yd0 - Yd2)*(Xs1 - Xs2)
WiredHome 167:8aa3fb2a5a31 690 /// E = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 691 /// Divider
WiredHome 167:8aa3fb2a5a31 692 ///
WiredHome 167:8aa3fb2a5a31 693 ///
WiredHome 167:8aa3fb2a5a31 694 /// Ys0*(Xs2*Yd1 - Xs1*Yd2) +
WiredHome 167:8aa3fb2a5a31 695 /// Ys1*(Xs0*Yd2 - Xs2*Yd0) +
WiredHome 167:8aa3fb2a5a31 696 /// Ys2*(Xs1*Yd0 - Xs0*Yd1)
WiredHome 167:8aa3fb2a5a31 697 /// F = ---------------------------------------------------
WiredHome 167:8aa3fb2a5a31 698 /// Divider
WiredHome 167:8aa3fb2a5a31 699 ///
WiredHome 167:8aa3fb2a5a31 700 ///
WiredHome 167:8aa3fb2a5a31 701 /// Return: OK - the calibration matrix was correctly
WiredHome 167:8aa3fb2a5a31 702 /// calculated and its value is in the
WiredHome 167:8aa3fb2a5a31 703 /// output argument.
WiredHome 167:8aa3fb2a5a31 704 /// NOT_OK - an error was detected and the
WiredHome 167:8aa3fb2a5a31 705 /// function failed to return a valid
WiredHome 167:8aa3fb2a5a31 706 /// set of matrix values.
WiredHome 167:8aa3fb2a5a31 707 /// The only time this sample code returns
WiredHome 167:8aa3fb2a5a31 708 /// NOT_OK is when Divider == 0
WiredHome 167:8aa3fb2a5a31 709 ///
WiredHome 167:8aa3fb2a5a31 710 ///
WiredHome 167:8aa3fb2a5a31 711 ///
WiredHome 167:8aa3fb2a5a31 712 /// NOTE! NOTE! NOTE!
WiredHome 167:8aa3fb2a5a31 713 ///
WiredHome 167:8aa3fb2a5a31 714 /// setCalibrationMatrix() and getDisplayPoint() will do fine
WiredHome 167:8aa3fb2a5a31 715 /// for you as they are, provided that your digitizer
WiredHome 167:8aa3fb2a5a31 716 /// resolution does not exceed 10 bits (1024 values). Higher
WiredHome 167:8aa3fb2a5a31 717 /// resolutions may cause the integer operations to overflow
WiredHome 167:8aa3fb2a5a31 718 /// and return incorrect values. If you wish to use these
WiredHome 167:8aa3fb2a5a31 719 /// functions with digitizer resolutions of 12 bits (4096
WiredHome 167:8aa3fb2a5a31 720 /// values) you will either have to a) use 64-bit signed
WiredHome 167:8aa3fb2a5a31 721 /// integer variables and math, or b) judiciously modify the
WiredHome 167:8aa3fb2a5a31 722 /// operations to scale results by a factor of 2 or even 4.
WiredHome 167:8aa3fb2a5a31 723 ///
WiredHome 167:8aa3fb2a5a31 724 /// </pre>
WiredHome 167:8aa3fb2a5a31 725 ///
WiredHome 81:01da2e34283d 726 RetCode_t RA8875::TouchPanelComputeCalibration(point_t * displayPtr, point_t * screenPtr, tpMatrix_t * matrixPtr)
WiredHome 78:faf49c381591 727 {
WiredHome 78:faf49c381591 728 RetCode_t retValue = noerror;
WiredHome 78:faf49c381591 729
WiredHome 78:faf49c381591 730 tpMatrix.Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
WiredHome 78:faf49c381591 731 ((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
WiredHome 78:faf49c381591 732
WiredHome 78:faf49c381591 733 if( tpMatrix.Divider == 0 ) {
WiredHome 78:faf49c381591 734 retValue = bad_parameter;
WiredHome 78:faf49c381591 735 } else {
WiredHome 78:faf49c381591 736 tpMatrix.An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
WiredHome 78:faf49c381591 737 ((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
WiredHome 78:faf49c381591 738
WiredHome 78:faf49c381591 739 tpMatrix.Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
WiredHome 78:faf49c381591 740 ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
WiredHome 78:faf49c381591 741
WiredHome 78:faf49c381591 742 tpMatrix.Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
WiredHome 78:faf49c381591 743 (screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
WiredHome 78:faf49c381591 744 (screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
WiredHome 78:faf49c381591 745
WiredHome 78:faf49c381591 746 tpMatrix.Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
WiredHome 78:faf49c381591 747 ((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
WiredHome 78:faf49c381591 748
WiredHome 78:faf49c381591 749 tpMatrix.En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
WiredHome 78:faf49c381591 750 ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
WiredHome 78:faf49c381591 751
WiredHome 78:faf49c381591 752 tpMatrix.Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
WiredHome 78:faf49c381591 753 (screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
WiredHome 78:faf49c381591 754 (screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
WiredHome 83:7bad0068cca0 755 touchState = no_touch;
WiredHome 78:faf49c381591 756 if (matrixPtr)
WiredHome 78:faf49c381591 757 memcpy(matrixPtr, &tpMatrix, sizeof(tpMatrix_t));
WiredHome 78:faf49c381591 758 }
WiredHome 78:faf49c381591 759 return( retValue ) ;
WiredHome 78:faf49c381591 760 }
WiredHome 78:faf49c381591 761
WiredHome 157:1565f38ca44b 762 void RA8875::ResTouchPanelCfg(const char * _tpFQFN, const char * _tpCalMessage)
WiredHome 157:1565f38ca44b 763 {
WiredHome 157:1565f38ca44b 764 tpFQFN = _tpFQFN;
WiredHome 157:1565f38ca44b 765 tpCalMessage = _tpCalMessage;
WiredHome 157:1565f38ca44b 766 }
WiredHome 157:1565f38ca44b 767
WiredHome 157:1565f38ca44b 768
WiredHome 157:1565f38ca44b 769 RetCode_t RA8875::_internal_ts_cal()
WiredHome 157:1565f38ca44b 770 {
WiredHome 157:1565f38ca44b 771 FILE * fh;
WiredHome 157:1565f38ca44b 772 tpMatrix_t matrix;
WiredHome 157:1565f38ca44b 773 RetCode_t r = noerror;
WiredHome 190:3132b7dfad82 774
WiredHome 157:1565f38ca44b 775 if (tpFQFN) {
WiredHome 157:1565f38ca44b 776 fh = fopen(tpFQFN, "rb");
WiredHome 157:1565f38ca44b 777 if (fh) {
WiredHome 157:1565f38ca44b 778 fread(&matrix, sizeof(tpMatrix_t), 1, fh);
WiredHome 157:1565f38ca44b 779 fclose(fh);
WiredHome 157:1565f38ca44b 780 TouchPanelSetMatrix(&matrix);
WiredHome 157:1565f38ca44b 781 } else {
WiredHome 157:1565f38ca44b 782 r = TouchPanelCalibrate(tpCalMessage, &matrix);
WiredHome 157:1565f38ca44b 783 if (r == noerror) {
WiredHome 157:1565f38ca44b 784 fh = fopen(tpFQFN, "wb");
WiredHome 157:1565f38ca44b 785 if (fh) {
WiredHome 157:1565f38ca44b 786 fwrite(&matrix, sizeof(tpMatrix_t), 1, fh);
WiredHome 157:1565f38ca44b 787 fclose(fh);
WiredHome 157:1565f38ca44b 788 INFO(" tp cal written to '%s'.", tpFQFN);
WiredHome 157:1565f38ca44b 789 } else {
WiredHome 157:1565f38ca44b 790 ERR(" couldn't open tpcal file '%s'.", tpFQFN);
WiredHome 157:1565f38ca44b 791 r = file_not_found;
WiredHome 157:1565f38ca44b 792 }
WiredHome 157:1565f38ca44b 793 } else {
WiredHome 157:1565f38ca44b 794 ERR("error return: %d", r);
WiredHome 157:1565f38ca44b 795 }
WiredHome 157:1565f38ca44b 796 HexDump("TPCal", (const uint8_t *)&matrix, sizeof(tpMatrix_t));
WiredHome 157:1565f38ca44b 797 cls();
WiredHome 157:1565f38ca44b 798 }
WiredHome 157:1565f38ca44b 799 }
WiredHome 157:1565f38ca44b 800 return r;
WiredHome 157:1565f38ca44b 801 }
WiredHome 157:1565f38ca44b 802
WiredHome 157:1565f38ca44b 803
WiredHome 157:1565f38ca44b 804
WiredHome 124:1690a7ae871c 805 ////////////////// Capacitive Touch Panel
WiredHome 124:1690a7ae871c 806
WiredHome 165:695c24cc5197 807 uint8_t RA8875::FT5206_ReadRegU8(uint8_t reg) {
WiredHome 124:1690a7ae871c 808 char val;
WiredHome 190:3132b7dfad82 809
WiredHome 124:1690a7ae871c 810 m_i2c->write(m_addr, (const char *)&reg, 1);
WiredHome 124:1690a7ae871c 811 m_i2c->read(m_addr, &val, 1);
WiredHome 181:0032d1b8f5d4 812 //INFO("ReadReg %02X, Val %02X", reg, val);
WiredHome 124:1690a7ae871c 813 return (uint8_t)val;
WiredHome 124:1690a7ae871c 814 }
WiredHome 124:1690a7ae871c 815
WiredHome 124:1690a7ae871c 816 // Interrupt for touch detection
WiredHome 124:1690a7ae871c 817 void RA8875::TouchPanelISR(void)
WiredHome 124:1690a7ae871c 818 {
WiredHome 165:695c24cc5197 819 if (useTouchPanel == TP_FT5206) {
WiredHome 198:9b6851107426 820 if (FT5206_TouchPositions()) {
WiredHome 165:695c24cc5197 821 panelTouched = true;
WiredHome 198:9b6851107426 822 timeSinceTouch.reset();
WiredHome 198:9b6851107426 823 }
WiredHome 165:695c24cc5197 824 } else if (useTouchPanel == TP_GSL1680) {
WiredHome 198:9b6851107426 825 if (GSL1680_TouchPositions()) {
WiredHome 165:695c24cc5197 826 panelTouched = true;
WiredHome 198:9b6851107426 827 timeSinceTouch.reset();
WiredHome 198:9b6851107426 828 }
WiredHome 165:695c24cc5197 829 }
WiredHome 124:1690a7ae871c 830 }
WiredHome 124:1690a7ae871c 831
WiredHome 78:faf49c381591 832 // #### end of touch panel code additions