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
42 static int ELO_MIN_X = 400;
43 static int ELO_MAX_X = 3670;
44 static int ELO_MIN_Y = 500;
45 static 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 */
eloParsePacket(unsigned char * mousebuf,int * dx,int * dy,int * button_state)81 int 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 */
eloConvertXY(_THIS,int * dx,int * dy)121 void 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 */
eloGetPacket(unsigned char * buffer,int * buffer_p,int * checksum,int fd)134 int 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
eloSendPacket(unsigned char * packet,int fd)187 int 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 */
eloWaitForInput(int fd,int timeout)215 int 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 */
eloWaitReply(unsigned char type,unsigned char * reply,int fd)232 int 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
eloWaitAck(int fd)272 int 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 */
eloSendQuery(unsigned char * request,unsigned char * reply,int fd)298 int 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 */
eloSendControl(unsigned char * control,int fd)316 int 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 */
eloInitController(int fd)327 int 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
eloReadPosition(_THIS,int fd,int * x,int * y,int * button_state,int * realx,int * realy)421 int 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