| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2012 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| #include <unistd.h> |
| #include <sys/time.h> |
| #include <ctype.h> |
| |
| #include "SDL_stdinc.h" |
| #include "SDL_fbvideo.h" |
| #include "SDL_fbelo.h" |
| |
| /* |
| calibration default values |
| values are read from the following environment variables: |
| |
| SDL_ELO_MIN_X |
| SDL_ELO_MAX_X |
| SDL_ELO_MIN_Y |
| SDL_ELO_MAX_Y |
| */ |
| |
| static int ELO_MIN_X = 400; |
| static int ELO_MAX_X = 3670; |
| static int ELO_MIN_Y = 500; |
| static int ELO_MAX_Y = 3540; |
| |
| #define ELO_SNAP_SIZE 6 |
| #define ELO_TOUCH_BYTE 'T' |
| #define ELO_ID 'I' |
| #define ELO_MODE 'M' |
| #define ELO_PARAMETER 'P' |
| #define ELO_REPORT 'B' |
| #define ELO_ACK 'A' |
| |
| #define ELO_INIT_CHECKSUM 0xAA |
| |
| #define ELO_BTN_PRESS 0x01 |
| #define ELO_STREAM 0x02 |
| #define ELO_BTN_RELEASE 0x04 |
| |
| #define ELO_TOUCH_MODE 0x01 |
| #define ELO_STREAM_MODE 0x02 |
| #define ELO_UNTOUCH_MODE 0x04 |
| #define ELO_RANGE_CHECK_MODE 0x40 |
| #define ELO_TRIM_MODE 0x02 |
| #define ELO_CALIB_MODE 0x04 |
| #define ELO_SCALING_MODE 0x08 |
| #define ELO_TRACKING_MODE 0x40 |
| |
| #define ELO_SERIAL_MASK 0xF8 |
| |
| #define ELO_SERIAL_IO '0' |
| |
| #define ELO_MAX_TRIALS 3 |
| #define ELO_MAX_WAIT 100000 |
| #define ELO_UNTOUCH_DELAY 5 |
| #define ELO_REPORT_DELAY 1 |
| |
| /* eloParsePacket |
| */ |
| int eloParsePacket(unsigned char* mousebuf, int* dx, int* dy, int* button_state) { |
| static int elo_button = 0; |
| static int last_x = 0; |
| static int last_y = 0; |
| int x,y; |
| |
| /* Check if we have a touch packet */ |
| if (mousebuf[1] != ELO_TOUCH_BYTE) { |
| return 0; |
| } |
| |
| x = ((mousebuf[4] << 8) | mousebuf[3]); |
| y = ((mousebuf[6] << 8) | mousebuf[5]); |
| |
| if((SDL_abs(x - last_x) > ELO_SNAP_SIZE) || (SDL_abs(y - last_y) > ELO_SNAP_SIZE)) { |
| *dx = ((mousebuf[4] << 8) | mousebuf[3]); |
| *dy = ((mousebuf[6] << 8) | mousebuf[5]); |
| } |
| else { |
| *dx = last_x; |
| *dy = last_y; |
| } |
| |
| last_x = *dx; |
| last_y = *dy; |
| |
| if ( (mousebuf[2] & 0x07) == ELO_BTN_PRESS ) { |
| elo_button = 1; |
| } |
| if ( (mousebuf[2] & 0x07) == ELO_BTN_RELEASE ) { |
| elo_button = 0; |
| } |
| |
| *button_state = elo_button; |
| return 1; |
| } |
| |
| /* Convert the raw coordinates from the ELO controller |
| to a screen position. |
| */ |
| void eloConvertXY(_THIS, int *dx, int *dy) { |
| int input_x = *dx; |
| int input_y = *dy; |
| int width = ELO_MAX_X - ELO_MIN_X; |
| int height = ELO_MAX_Y - ELO_MIN_Y; |
| |
| *dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width); |
| *dy = (cache_vinfo.yres * (input_y - ELO_MIN_Y)) / height; |
| } |
| |
| |
| /* eloGetPacket |
| */ |
| int eloGetPacket(unsigned char* buffer, int* buffer_p, int* checksum, int fd) { |
| int num_bytes; |
| int ok; |
| |
| if(fd == 0) { |
| num_bytes = ELO_PACKET_SIZE; |
| } |
| else { |
| num_bytes = read(fd, |
| (char *) (buffer + *buffer_p), |
| ELO_PACKET_SIZE - *buffer_p); |
| } |
| |
| if (num_bytes < 0) { |
| #ifdef DEBUG_MOUSE |
| fprintf(stderr, "System error while reading from Elographics touchscreen.\n"); |
| #endif |
| return 0; |
| } |
| |
| while (num_bytes) { |
| if ((*buffer_p == 0) && (buffer[0] != ELO_START_BYTE)) { |
| SDL_memcpy(&buffer[0], &buffer[1], num_bytes-1); |
| } |
| else { |
| if (*buffer_p < ELO_PACKET_SIZE-1) { |
| *checksum = *checksum + buffer[*buffer_p]; |
| *checksum = *checksum % 256; |
| } |
| (*buffer_p)++; |
| } |
| num_bytes--; |
| } |
| |
| if (*buffer_p == ELO_PACKET_SIZE) { |
| ok = (*checksum == buffer[ELO_PACKET_SIZE-1]); |
| *checksum = ELO_INIT_CHECKSUM; |
| *buffer_p = 0; |
| |
| if (!ok) { |
| return 0; |
| } |
| |
| return 1; |
| } |
| else { |
| return 0; |
| } |
| } |
| |
| /* eloSendPacket |
| */ |
| |
| int eloSendPacket(unsigned char* packet, int fd) |
| { |
| int i, result; |
| int sum = ELO_INIT_CHECKSUM; |
| |
| packet[0] = ELO_START_BYTE; |
| for (i = 0; i < ELO_PACKET_SIZE-1; i++) { |
| sum += packet[i]; |
| sum &= 0xFF; |
| } |
| packet[ELO_PACKET_SIZE-1] = sum; |
| |
| result = write(fd, packet, ELO_PACKET_SIZE); |
| |
| if (result != ELO_PACKET_SIZE) { |
| #ifdef DEBUG_MOUSE |
| printf("System error while sending to Elographics touchscreen.\n"); |
| #endif |
| return 0; |
| } |
| else { |
| return 1; |
| } |
| } |
| |
| |
| /* eloWaitForInput |
| */ |
| int eloWaitForInput(int fd, int timeout) |
| { |
| fd_set readfds; |
| struct timeval to; |
| int r; |
| |
| FD_ZERO(&readfds); |
| FD_SET(fd, &readfds); |
| to.tv_sec = 0; |
| to.tv_usec = timeout; |
| |
| r = select(FD_SETSIZE, &readfds, NULL, NULL, &to); |
| return r; |
| } |
| |
| /* eloWaitReply |
| */ |
| int eloWaitReply(unsigned char type, unsigned char *reply, int fd) { |
| int ok; |
| int i, result; |
| int reply_p = 0; |
| int sum = ELO_INIT_CHECKSUM; |
| |
| i = ELO_MAX_TRIALS; |
| do { |
| ok = 0; |
| |
| result = eloWaitForInput(fd, ELO_MAX_WAIT); |
| |
| if (result > 0) { |
| ok = eloGetPacket(reply, &reply_p, &sum, fd); |
| |
| if (ok && reply[1] != type && type != ELO_PARAMETER) { |
| #ifdef DEBUG_MOUSE |
| fprintf(stderr, "Wrong reply received\n"); |
| #endif |
| ok = 0; |
| } |
| } |
| else { |
| #ifdef DEBUG_MOUSE |
| fprintf(stderr, "No input!\n"); |
| #endif |
| } |
| |
| if (result == 0) { |
| i--; |
| } |
| } while(!ok && (i>0)); |
| |
| return ok; |
| } |
| |
| |
| /* eloWaitAck |
| */ |
| |
| int eloWaitAck(int fd) { |
| unsigned char packet[ELO_PACKET_SIZE]; |
| int i, nb_errors; |
| |
| if (eloWaitReply(ELO_ACK, packet, fd)) { |
| for (i = 0, nb_errors = 0; i < 4; i++) { |
| if (packet[2 + i] != '0') { |
| nb_errors++; |
| } |
| } |
| |
| if (nb_errors != 0) { |
| #ifdef DEBUG_MOUSE |
| fprintf(stderr, "Elographics acknowledge packet reports %d errors\n", nb_errors); |
| #endif |
| } |
| return 1; |
| } |
| else { |
| return 0; |
| } |
| } |
| |
| |
| /* eloSendQuery -- |
| */ |
| int eloSendQuery(unsigned char *request, unsigned char* reply, int fd) { |
| int ok; |
| |
| if (eloSendPacket(request, fd)) { |
| ok = eloWaitReply(toupper(request[1]), reply, fd); |
| if (ok) { |
| ok = eloWaitAck(fd); |
| } |
| return ok; |
| } |
| else { |
| return 0; |
| } |
| } |
| |
| |
| /* eloSendControl |
| */ |
| int eloSendControl(unsigned char* control, int fd) { |
| if (eloSendPacket(control, fd)) { |
| return eloWaitAck(fd); |
| } |
| else { |
| return 0; |
| } |
| } |
| |
| /* eloInitController |
| */ |
| int eloInitController(int fd) { |
| unsigned char req[ELO_PACKET_SIZE]; |
| unsigned char reply[ELO_PACKET_SIZE]; |
| const char *buffer = NULL; |
| int result = 0; |
| |
| struct termios mouse_termios; |
| |
| /* try to read the calibration values */ |
| buffer = SDL_getenv("SDL_ELO_MIN_X"); |
| if(buffer) { |
| ELO_MIN_X = SDL_atoi(buffer); |
| } |
| buffer = SDL_getenv("SDL_ELO_MAX_X"); |
| if(buffer) { |
| ELO_MAX_X = SDL_atoi(buffer); |
| } |
| buffer = SDL_getenv("SDL_ELO_MIN_Y"); |
| if(buffer) { |
| ELO_MIN_Y = SDL_atoi(buffer); |
| } |
| buffer = SDL_getenv("SDL_ELO_MAX_Y"); |
| if(buffer) { |
| ELO_MAX_Y = SDL_atoi(buffer); |
| } |
| |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "ELO calibration values:\nmin_x: %i\nmax_x: %i\nmin_y: %i\nmax_y: %i\n", |
| ELO_MIN_X, |
| ELO_MAX_X, |
| ELO_MIN_Y, |
| ELO_MAX_Y); |
| #endif |
| |
| /* set comm params */ |
| SDL_memset(&mouse_termios, 0, sizeof(mouse_termios)); |
| mouse_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; |
| mouse_termios.c_cc[VMIN] = 1; |
| result = tcsetattr(fd, TCSANOW, &mouse_termios); |
| |
| if (result < 0) { |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "Unable to configure Elographics touchscreen port\n"); |
| #endif |
| return 0; |
| } |
| |
| SDL_memset(req, 0, ELO_PACKET_SIZE); |
| req[1] = tolower(ELO_PARAMETER); |
| if (!eloSendQuery(req, reply, fd)) { |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "Not at the specified rate or model 2310, will continue\n"); |
| #endif |
| } |
| |
| SDL_memset(req, 0, ELO_PACKET_SIZE); |
| req[1] = tolower(ELO_ID); |
| if (eloSendQuery(req, reply, fd)) { |
| #ifdef DEBUG_MOUSE |
| fprintf(stderr, "Ok, controller configured!\n"); |
| #endif |
| } |
| else { |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "Unable to ask Elographics touchscreen identification\n"); |
| #endif |
| return 0; |
| } |
| |
| SDL_memset(req, 0, ELO_PACKET_SIZE); |
| req[1] = ELO_MODE; |
| req[3] = ELO_TOUCH_MODE | ELO_STREAM_MODE | ELO_UNTOUCH_MODE; |
| req[4] = ELO_TRACKING_MODE; |
| if (!eloSendControl(req, fd)) { |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "Unable to change Elographics touchscreen operating mode\n"); |
| #endif |
| return 0; |
| } |
| |
| SDL_memset(req, 0, ELO_PACKET_SIZE); |
| req[1] = ELO_REPORT; |
| req[2] = ELO_UNTOUCH_DELAY; |
| req[3] = ELO_REPORT_DELAY; |
| if (!eloSendControl(req, fd)) { |
| #ifdef DEBUG_MOUSE |
| fprintf( stderr, "Unable to change Elographics touchscreen reports timings\n"); |
| #endif |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| int eloReadPosition(_THIS, int fd, int* x, int* y, int* button_state, int* realx, int* realy) { |
| unsigned char buffer[ELO_PACKET_SIZE]; |
| int pointer = 0; |
| int checksum = ELO_INIT_CHECKSUM; |
| |
| while(pointer < ELO_PACKET_SIZE) { |
| if(eloGetPacket(buffer, &pointer, &checksum, fd)) { |
| break; |
| } |
| } |
| |
| if(!eloParsePacket(buffer, realx, realy, button_state)) { |
| return 0; |
| } |
| |
| *x = *realx; |
| *y = *realy; |
| |
| eloConvertXY(this, x, y); |
| |
| return 1; |
| } |