Calibracion de un TouchScreen

[jgpeiro06]

Hola a todos,

tengo una placa de desarrollo con un touchscreen y necesito hacer algún algoritmo para calibrarlo. El metodo para calibrar es el tipico, se van mostrando unos puntos en la pantalla y el usuario va presionando sobre ellos....

Creo que tengo que obtener los coeficientes de dos polinomio de grado 1 o 2 que luego aplicare a cada entrada de X e Y?
Una vez tengo los valores X e Y de las 4 esquinas y el centro,¿que hago con ellos para obtener estos polinomios?

Saludos

[jgpeiro06]

...llevo 237 mensajes escritos en el foro... y este me ha demostrado que aun empiezo a construir la casa por el tejado, me explico:
justo despues de postear se me a ocurrido buscar en google "touchscreen calibration algorithm" y el primer resultado es justo lo que buscaba, un appnote de TI llamado "Calibration in touch-screen systems"...

http://focus.ti.com/lit/an/slyt277/slyt277.pdf

bueno, a ver si la proxima vez miro un poco por la red antes de postear...

[jhozate]

de todas formas gracias por linkarnos la nota

[chichepic]

Seria muy bueno conocer los resultados !

[Nocturno]

¡Joder!, qué complicado ese pdf.

Yo recuerdo que lo hice en una ocasión y resultó bastante sencillo; una regla de tres para cada eje y listo.

[jgpeiro06]

Yo recuerdo que lo hice en una ocasión y resultó bastante sencillo; una regla de tres para cada eje y listo.

Si yo también hice eso al principio, pero así no pude conseguir toda la precisión que quería. Ademas, por lo menos en mi touch screen, los valores de X que tomas en las dos esquinas inferiores varían ligeramente de los dos que tomas en las esquinas superiores, así que la formula para transformar las coordenadas tenia que ser algo mas compleja que una regla de tres.

Leyendo el PDF de TI he visto que dan la formula matricial para calcular los coeficientes de compensación para todos los puntos que queramos. Ademas, para mas de 3 puntos, las soluciones a esas ecuaciones matriciales se hacen largas y difíciles de manejar, así que dan una solución equivalente pero bien ordenada para que sea sencilla de manejar.

Os lo copio aquí para quien lo pueda necesitar:

Código: C

1. Convert Touch to LCD   
2.         X = alpha_x * Xp + beta_x * Yp + deltaX;
3.         Y = alpha_y * Xp + beta_y * Yp + deltaY;

Donde:
Xp e Yp son los valores medidos del touch screen.
X e Y son los pixels correspondiente en el LCD.
alpha_x, beta_x y deltaX son los coeficientes de compensacion para el eje X. Estas se obtienen durante la calibración.
alpha_y, beta_y y deltaY son los coeficientes de compensacion para el eje Y. Estas se obtienen durante la calibración.

Código: C

1. Calibrate Touch for n points
2.  
3.         alpha_x = delta_x1 / delta;
4.         betha_x = delta_x2 / delta;
5.         deltaX = delta_x3 / delta;
6.        
7.         alpha_y = delta_y1 / delta;
8.         betha_y = delta_y2 / delta;
9.         deltaY = delta_y3 / delta;
10.        
11.        
12.         delta = n*(a*b - c*c) + 2*c*d*e - a*e*e - b*d*d;
13.        
14.         delta_x1 = n*(X1*b - X2*c) + e*(X2*d - X1*e) + X3*(c*e - b*d);
15.         delta_x2 = n*(X2*a - X1*c) + d*(X1*e - X2*d) + X3*(c*d - a*e);
16.         delta_x3 = X3*(a*b - c*c) + X1*(c*e - b*d) + X2*(c*d - a*e);
17.        
18.         delta_y1 = n*(Y1*b - Y2*c) + e*(Y2*d - Y1*e) + Y3*(c*e - b*d);
19.         delta_y2 = n*(Y2*a - Y1*c) + d*(Y1*e - Y2*d) + Y3*(c*d - a*e);
20.         delta_y3 = Y3*(a*b - c*c) + Y1*(c*e - b*d) + Y2*(c*d - a*e);
21.        
22.        
23.         a = sum( Xp[k]*Xp[k], k, 0, n-1 );
24.         b = sum( Yp[k]*Yp[k], k, 0, n-1 );
25.         c = sum( Xp[k]*Yp[k], k, 0, n-1 );
26.         d = sum( Xp[k], k, 0, n-1 );
27.         e = sum( Yp[k], k, 0, n-1 );
28.        
29.         X1 = sum( Xp[k]*X[k], k, 0, n-1 );
30.         X2 = sum( Yp[k]*X[k], k, 0, n-1 );
31.         X3 = sum( X[k], k, 0, n-1 );
32.        
33.         Y1 = sum( Xp[k]*Y[k], k, 0, n-1 );
34.         Y2 = sum( Yp[k]*Y[k], k, 0, n-1 );
35.         Y3 = sum( Y[k], k, 0, n-1 );

Donde
Xp[N] e Yp[N] son los N valores medidos del touch screen.
X[N] e Y[N] son los N pixels correspondiente en el LCD.
sum( f, v, s, e ) es el sumatorio de f[v] desde v=s hasta v=e

Tambien hay otro PDF de analog.com con informacion similar aqui: http://www.analog.com/static/imported-files/application_notes/AN-1021.pdf

Saludos

Modificado un pequeño error en las variables delta_x1 y delta_y1.

[Nocturno]

Bueno, pues parece que la conclusión final es muy parecida. Busqué lo que yo hice y es esto:

Código: C

1. // Cálculo de los parámetros de calibración
2.      EscalaX = 120.0 / (aa-xx);
3.      EscalaY = 56.0 / (bb-yy);
4.      OffsetX=xx-4/EscalaX;
5.      OffsetY=yy-4/EscalaY;
6.      guarda_calibracion();

Donde (aa,bb) son la lectura del punto marcado en la esquina superior izquierda y (xx,yy) la del punto marcado en la esquina inferior derecha.

[jgpeiro06]

Bueno, pues parece que la conclusión final es muy parecida...

Yo también tenia esta solución implementada que funcionaba aceptablemente y a la que había llegado midiendo varios puntos de prueba y haciendo algunos cálculos simples. Pero no supe desarrollar un algoritmo de calibración para ajustar las constantes de compensación en tiempo de ejecución para poder calibrar el display "in situ".

Código: C

1. X = ( TouchPanelReadX() * 240 ) / 3600;
2.     Y = 320 - ( TouchPanelReadY() * 320 ) / 3600 + 20 ;

Seria muy bueno conocer los resultados !

No tengo manera de mostraros los resultados. Pero si os digo que lo he probado y funciona a la perfección.

[falflores]

Yo recuerdo que lo hice en una ocasión y resultó bastante sencillo; una regla de tres para cada eje y listo.

Si yo también hice eso al principio, pero así no pude conseguir toda la precisión que quería. Ademas, por lo menos en mi touch screen, los valores de X que tomas en las dos esquinas inferiores varían ligeramente de los dos que tomas en las esquinas superiores, así que la formula para transformar las coordenadas tenia que ser algo mas compleja que una regla de tres.

Leyendo el PDF de TI he visto que dan la formula matricial para calcular los coeficientes de compensación para todos los puntos que queramos. Ademas, para mas de 3 puntos, las soluciones a esas ecuaciones matriciales se hacen largas y difíciles de manejar, así que dan una solución equivalente pero bien ordenada para que sea sencilla de manejar.

Os lo copio aquí para quien lo pueda necesitar:

Código: C

1. Convert Touch to LCD   
2.         X = alpha_x * Xp + beta_x * Yp + deltaX;
3.         Y = alpha_y * Xp + beta_y * Yp + deltaY;

Donde:
Xp e Yp son los valores medidos del touch screen.
X e Y son los pixels correspondiente en el LCD.
alpha_x, beta_x y deltaX son los coeficientes de compensacion para el eje X. Estas se obtienen durante la calibración.
alpha_y, beta_y y deltaY son los coeficientes de compensacion para el eje Y. Estas se obtienen durante la calibración.

Código: C

1. Calibrate Touch for n points
2.  
3.         alpha_x = delta_x1 / delta;
4.         betha_x = delta_x2 / delta;
5.         deltaX = delta_x3 / delta;
6.        
7.         alpha_y = delta_y1 / delta;
8.         betha_y = delta_y2 / delta;
9.         deltaY = delta_y3 / delta;
10.        
11.        
12.         delta = n*(a*b - c*c) + 2*c*d*e - a*e*e - b*d*d;
13.        
14.         delta_x1 = n*(X1*b - X2*c) + e*(X2*d - X1*e) + X3*(c*e - b*d);
15.         delta_x2 = n*(X2*a - X1*c) + d*(X1*e - X2*d) + X3*(c*d - a*e);
16.         delta_x3 = X3*(a*b - c*c) + X1*(c*e - b*d) + X2*(c*d - a*e);
17.        
18.         delta_y1 = n*(Y1*b - Y2*c) + e*(Y2*d - Y1*e) + Y3*(c*e - b*d);
19.         delta_y2 = n*(Y2*a - Y1*c) + d*(Y1*e - Y2*d) + Y3*(c*d - a*e);
20.         delta_y3 = Y3*(a*b - c*c) + Y1*(c*e - b*d) + Y2*(c*d - a*e);
21.        
22.        
23.         a = sum( Xp[k]*Xp[k], k, 0, n-1 );
24.         b = sum( Yp[k]*Yp[k], k, 0, n-1 );
25.         c = sum( Xp[k]*Yp[k], k, 0, n-1 );
26.         d = sum( Xp[k], k, 0, n-1 );
27.         e = sum( Yp[k], k, 0, n-1 );
28.        
29.         X1 = sum( Xp[k]*X[k], k, 0, n-1 );
30.         X2 = sum( Yp[k]*X[k], k, 0, n-1 );
31.         X3 = sum( X[k], k, 0, n-1 );
32.        
33.         Y1 = sum( Xp[k]*Y[k], k, 0, n-1 );
34.         Y2 = sum( Yp[k]*Y[k], k, 0, n-1 );
35.         Y3 = sum( Y[k], k, 0, n-1 );

Donde
Xp[N] e Yp[N] son los N valores medidos del touch screen.
X[N] e Y[N] son los N pixels correspondiente en el LCD.
sum( f, v, s, e ) es el sumatorio de f[v] desde v=s hasta v=e

Tambien hay otro PDF de analog.com con informacion similar aqui: http://www.analog.com/static/imported-files/application_notes/AN-1021.pdf

Saludos

Modificado un pequeño error en las variables delta_x1 y delta_y1.

Hola amigo, se que ya tiene tiempo tu post, pero recientemente me encuentro en una situación parecida a la tuya, me encuentro calibrando un touch screen resistió, y después de analizar la pagina que anexaste, comprendí como funciona el algoritmo de calibración, es un sistema de 6 ecuaciones con 6 incógnitas, ahora, por cual método soluciona el sistema tu algoritmo, por el de gauss Jordán?.

Otra inquietud que me aqueja es que le implemente el algoritmo a mi touch screen, pero resulta que las mediciones que me arroja no son lineales, en la esquina superior izquierda comienzo a medir y todo bien, pero entre mas me alejo hacia a la derecha y hacia abajo, las lecturas de ambos ejes se van haciendo exponenciales, y el algoritmo ya no es eficiente en estos puntos. Te pregunto: sabes y este algoritmo es solo para ecuaciones lineales? es esto normal? O la forma en la que mido los voltajes del touch screen no son las correctas y la relación si debe ser lineal?

Espero que aun recuerdes un poco la forma de hacerlo. Gracias por tu tiempo