1/* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 Sam Lantinga 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken@libsdl.org 21*/ 22#include "SDL_config.h" 23 24#include <unistd.h> 25#include <sys/time.h> 26#include <ctype.h> 27 28#include "SDL_stdinc.h" 29#include "SDL_fbvideo.h" 30#include "SDL_fbelo.h" 31 32/* 33 calibration default values 34 values are read from the following environment variables: 35 36 SDL_ELO_MIN_X 37 SDL_ELO_MAX_X 38 SDL_ELO_MIN_Y 39 SDL_ELO_MAX_Y 40*/ 41 42static int ELO_MIN_X = 400; 43static int ELO_MAX_X = 3670; 44static int ELO_MIN_Y = 500; 45static int ELO_MAX_Y = 3540; 46 47#define ELO_SNAP_SIZE 6 48#define ELO_TOUCH_BYTE 'T' 49#define ELO_ID 'I' 50#define ELO_MODE 'M' 51#define ELO_PARAMETER 'P' 52#define ELO_REPORT 'B' 53#define ELO_ACK 'A' 54 55#define ELO_INIT_CHECKSUM 0xAA 56 57#define ELO_BTN_PRESS 0x01 58#define ELO_STREAM 0x02 59#define ELO_BTN_RELEASE 0x04 60 61#define ELO_TOUCH_MODE 0x01 62#define ELO_STREAM_MODE 0x02 63#define ELO_UNTOUCH_MODE 0x04 64#define ELO_RANGE_CHECK_MODE 0x40 65#define ELO_TRIM_MODE 0x02 66#define ELO_CALIB_MODE 0x04 67#define ELO_SCALING_MODE 0x08 68#define ELO_TRACKING_MODE 0x40 69 70#define ELO_SERIAL_MASK 0xF8 71 72#define ELO_SERIAL_IO '0' 73 74#define ELO_MAX_TRIALS 3 75#define ELO_MAX_WAIT 100000 76#define ELO_UNTOUCH_DELAY 5 77#define ELO_REPORT_DELAY 1 78 79/* eloParsePacket 80*/ 81int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) { 82 static int elo_button = 0; 83 static int last_x = 0; 84 static int last_y = 0; 85 int x,y; 86 87 /* Check if we have a touch packet */ 88 if (mousebuf[1] != ELO_TOUCH_BYTE) { 89 return 0; 90 } 91 92 x = ((mousebuf[4] << 8) | mousebuf[3]); 93 y = ((mousebuf[6] << 8) | mousebuf[5]); 94 95 if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) || (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) { 96 *dx = ((mousebuf[4] << 8) | mousebuf[3]); 97 *dy = ((mousebuf[6] << 8) | mousebuf[5]); 98 } 99 else { 100 *dx = last_x; 101 *dy = last_y; 102 } 103 104 last_x = *dx; 105 last_y = *dy; 106 107 if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) { 108 elo_button = 1; 109 } 110 if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) { 111 elo_button = 0; 112 } 113 114 *button_state = elo_button; 115 return 1; 116} 117 118/* Convert the raw coordinates from the ELO controller 119 to a screen position. 120*/ 121void eloConvertXY(_THIS, int *dx, int *dy) { 122 int input_x = *dx; 123 int input_y = *dy; 124 int width = ELO_MAX_X - ELO_MIN_X; 125 int height = ELO_MAX_Y - ELO_MIN_Y; 126 127 *dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width); 128 *dy = (cache_vinfo.yres * (input_y - ELO_MIN_Y)) / height; 129} 130 131 132/* eloGetPacket 133*/ 134int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) { 135 int num_bytes; 136 int ok; 137 138 if(fd == 0) { 139 num_bytes = ELO_PACKET_SIZE; 140 } 141 else { 142 num_bytes = read(fd, 143 (char *) (buffer + *buffer_p), 144 ELO_PACKET_SIZE - *buffer_p); 145 } 146 147 if (num_bytes < 0) { 148#ifdef DEBUG_MOUSE 149 fprintf(stderr, "System error while reading from Elographics touchscreen.\n"); 150#endif 151 return 0; 152 } 153 154 while (num_bytes) { 155 if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) { 156 SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1); 157 } 158 else { 159 if (*buffer_p < ELO_PACKET_SIZE-1) { 160 *checksum = *checksum + buffer[*buffer_p]; 161 *checksum = *checksum % 256; 162 } 163 (*buffer_p)++; 164 } 165 num_bytes--; 166 } 167 168 if (*buffer_p == ELO_PACKET_SIZE) { 169 ok = (*checksum == buffer[ELO_PACKET_SIZE-1]); 170 *checksum = ELO_INIT_CHECKSUM; 171 *buffer_p = 0; 172 173 if (!ok) { 174 return 0; 175 } 176 177 return 1; 178 } 179 else { 180 return 0; 181 } 182} 183 184/* eloSendPacket 185*/ 186 187int eloSendPacket(unsigned char* packet, int fd) 188{ 189 int i, result; 190 int sum = ELO_INIT_CHECKSUM; 191 192 packet[0] = ELO_START_BYTE; 193 for (i = 0; i < ELO_PACKET_SIZE-1; i++) { 194 sum += packet[i]; 195 sum &= 0xFF; 196 } 197 packet[ELO_PACKET_SIZE-1] = sum; 198 199 result = write(fd, packet, ELO_PACKET_SIZE); 200 201 if (result != ELO_PACKET_SIZE) { 202#ifdef DEBUG_MOUSE 203 printf("System error while sending to Elographics touchscreen.\n"); 204#endif 205 return 0; 206 } 207 else { 208 return 1; 209 } 210} 211 212 213/* eloWaitForInput 214 */ 215int eloWaitForInput(int fd, int timeout) 216{ 217 fd_set readfds; 218 struct timeval to; 219 int r; 220 221 FD_ZERO(&readfds); 222 FD_SET(fd, &readfds); 223 to.tv_sec = 0; 224 to.tv_usec = timeout; 225 226 r = select(FD_SETSIZE, &readfds, NULL, NULL, &to); 227 return r; 228} 229 230/* eloWaitReply 231 */ 232int eloWaitReply(unsigned char type, unsigned char *reply, int fd) { 233 int ok; 234 int i, result; 235 int reply_p = 0; 236 int sum = ELO_INIT_CHECKSUM; 237 238 i = ELO_MAX_TRIALS; 239 do { 240 ok = 0; 241 242 result = eloWaitForInput(fd, ELO_MAX_WAIT); 243 244 if (result > 0) { 245 ok = eloGetPacket(reply, &reply_p, &sum, fd); 246 247 if (ok && reply[1] != type && type != ELO_PARAMETER) { 248#ifdef DEBUG_MOUSE 249 fprintf(stderr, "Wrong reply received\n"); 250#endif 251 ok = 0; 252 } 253 } 254 else { 255#ifdef DEBUG_MOUSE 256 fprintf(stderr, "No input!\n"); 257#endif 258 } 259 260 if (result == 0) { 261 i--; 262 } 263 } while(!ok && (i>0)); 264 265 return ok; 266} 267 268 269/* eloWaitAck 270 */ 271 272int eloWaitAck(int fd) { 273 unsigned char packet[ELO_PACKET_SIZE]; 274 int i, nb_errors; 275 276 if (eloWaitReply(ELO_ACK, packet, fd)) { 277 for (i = 0, nb_errors = 0; i < 4; i++) { 278 if (packet[2 + i] != '0') { 279 nb_errors++; 280 } 281 } 282 283 if (nb_errors != 0) { 284#ifdef DEBUG_MOUSE 285 fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors); 286#endif 287 } 288 return 1; 289 } 290 else { 291 return 0; 292 } 293} 294 295 296/* eloSendQuery -- 297*/ 298int eloSendQuery(unsigned char *request, unsigned char* reply, int fd) { 299 int ok; 300 301 if (eloSendPacket(request, fd)) { 302 ok = eloWaitReply(toupper(request[1]), reply, fd); 303 if (ok) { 304 ok = eloWaitAck(fd); 305 } 306 return ok; 307 } 308 else { 309 return 0; 310 } 311} 312 313 314/* eloSendControl 315*/ 316int eloSendControl(unsigned char* control, int fd) { 317 if (eloSendPacket(control, fd)) { 318 return eloWaitAck(fd); 319 } 320 else { 321 return 0; 322 } 323} 324 325/* eloInitController 326*/ 327int eloInitController(int fd) { 328 unsigned char req[ELO_PACKET_SIZE]; 329 unsigned char reply[ELO_PACKET_SIZE]; 330 const char *buffer = NULL; 331 int result = 0; 332 333 struct termios mouse_termios; 334 335 /* try to read the calibration values */ 336 buffer = SDL_getenv("SDL_ELO_MIN_X"); 337 if(buffer) { 338 ELO_MIN_X = SDL_atoi(buffer); 339 } 340 buffer = SDL_getenv("SDL_ELO_MAX_X"); 341 if(buffer) { 342 ELO_MAX_X = SDL_atoi(buffer); 343 } 344 buffer = SDL_getenv("SDL_ELO_MIN_Y"); 345 if(buffer) { 346 ELO_MIN_Y = SDL_atoi(buffer); 347 } 348 buffer = SDL_getenv("SDL_ELO_MAX_Y"); 349 if(buffer) { 350 ELO_MAX_Y = SDL_atoi(buffer); 351 } 352 353#ifdef DEBUG_MOUSE 354 fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n", 355 ELO_MIN_X, 356 ELO_MAX_X, 357 ELO_MIN_Y, 358 ELO_MAX_Y); 359#endif 360 361 /* set comm params */ 362 SDL_memset(&mouse_termios, 0, sizeof(mouse_termios)); 363 mouse_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 364 mouse_termios.c_cc[VMIN] = 1; 365 result = tcsetattr(fd, TCSANOW, &mouse_termios); 366 367 if (result < 0) { 368#ifdef DEBUG_MOUSE 369 fprintf( stderr, "Unable to configure Elographics touchscreen port\n"); 370#endif 371 return 0; 372 } 373 374 SDL_memset(req, 0, ELO_PACKET_SIZE); 375 req[1] = tolower(ELO_PARAMETER); 376 if (!eloSendQuery(req, reply, fd)) { 377#ifdef DEBUG_MOUSE 378 fprintf( stderr, "Not at the specified rate or model 2310, will continue\n"); 379#endif 380 } 381 382 SDL_memset(req, 0, ELO_PACKET_SIZE); 383 req[1] = tolower(ELO_ID); 384 if (eloSendQuery(req, reply, fd)) { 385#ifdef DEBUG_MOUSE 386 fprintf(stderr, "Ok, controller configured!\n"); 387#endif 388 } 389 else { 390#ifdef DEBUG_MOUSE 391 fprintf( stderr, "Unable to ask Elographics touchscreen identification\n"); 392#endif 393 return 0; 394 } 395 396 SDL_memset(req, 0, ELO_PACKET_SIZE); 397 req[1] = ELO_MODE; 398 req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE; 399 req[4] = ELO_TRACKING_MODE; 400 if (!eloSendControl(req, fd)) { 401#ifdef DEBUG_MOUSE 402 fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n"); 403#endif 404 return 0; 405 } 406 407 SDL_memset(req, 0, ELO_PACKET_SIZE); 408 req[1] = ELO_REPORT; 409 req[2] = ELO_UNTOUCH_DELAY; 410 req[3] = ELO_REPORT_DELAY; 411 if (!eloSendControl(req, fd)) { 412#ifdef DEBUG_MOUSE 413 fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n"); 414#endif 415 return 0; 416 } 417 418 return 1; 419} 420 421int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) { 422 unsigned char buffer[ELO_PACKET_SIZE]; 423 int pointer = 0; 424 int checksum = ELO_INIT_CHECKSUM; 425 426 while(pointer < ELO_PACKET_SIZE) { 427 if(eloGetPacket(buffer, &pointer, &checksum, fd)) { 428 break; 429 } 430 } 431 432 if(!eloParsePacket(buffer, realx, realy, button_state)) { 433 return 0; 434 } 435 436 *x = *realx; 437 *y = *realy; 438 439 eloConvertXY(this, x, y); 440 441 return 1; 442} 443