src/video/fbcon/SDL_fbelo.c
author Sam Lantinga <slouken@libsdl.org>
Tue, 24 Jan 2006 06:36:43 +0000
changeset 1259 36f24cdfcda7
parent 769 b8d311d90021
child 1312 c9b51268668f
permissions -rw-r--r--
te: Thu, 17 Apr 2003 11:25:26 -0700 From: "Jim" Subject: [SDL] Frame buffer patches... Would seem that GCC 3.2.2 promotes all signed values to unsigned if any single vlaue is unsigned in an expression... for instance when calculating an elo touch position....evertyhign is an (int) except for cach_vinfo.xres which is unsigned. THerefore if y ou reverse the SDL_ELO_MIN_X and SDL_ELO_MAX_X values the resulging negative value pegs the expression to it's max. Attached it the accumu lated patch to typecast the unsigned values to (int) - *dx = (cache_vinfo.xres - (cache_vinfo.xres * (input_x - ELO_MIN_X)) / width); + *dx = ((int)cache_vinfo.xres - ((int)cache_vinfo.xres * (input_x - ELO_MIN_X)) / width); and also to provide quite failure to operations which have the screen currently locked... The touch screen I'm using the original values were exactly opposite of any position I touched on the screen - evaluating the math the expr ession SHOULD have handled reversing the min and max values - and after casting the unsigned .xres and .yres to a signed int - worked well. .. Jim

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2004 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id$";
#endif

#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <ctype.h>
#include <string.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((abs(x - last_x) > ELO_SNAP_SIZE) || (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)) {
			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 = getenv("SDL_ELO_MIN_X");
	if(buffer) {
		ELO_MIN_X = atoi(buffer);
	}
	buffer = getenv("SDL_ELO_MAX_X");
	if(buffer) {
		ELO_MAX_X = atoi(buffer);
	}
	buffer = getenv("SDL_ELO_MIN_Y");
	if(buffer) {
		ELO_MIN_Y = atoi(buffer);
	}
	buffer = getenv("SDL_ELO_MAX_Y");
	if(buffer) {
		ELO_MAX_Y = 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 */
	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;
	}

	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
	}

	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;
	}

	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;
	}

	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;
}