Buenas, alguien me sabría decir si la libreria UTouch.h sirve para la ITDB02 5.0'' de itead studio
o existe alguna otra valida.
muchas gracias de antemano
Tarde, pero lo encontré ...
Hoy conseguí encender la pantalla, pero la parte tactil sigue sin ir bien.
Tengo un mega con este shield : http://www.aqualedsource.com/shop/product_info.php?cPath=1_5&products_id=32
y esta pantalla : http://www.itead-europe.com/index.php/itead-studio-category/display/itdb02-5-0.html
Le cargue un codigo que deveria pintar un pixel en la coordenada que tocas, y solo pinta pixeles en el cuarto superior derecho de la pantalla. Me da la impresion que la pantalla tiene mas pixeles que el sensor tactil, eso es normal?
#include <UTFT.h> // Pantalla TFF
#include <UTouch.h> // Tactil
extern uint8_t SmallFont[]; // Fuente Pequeña
UTFT Pantalla(ITDB50,38,39,40,41);
UTouch Tactil(62,63,64,65,66);
int X,Y;
void setup()
{
Pantalla.InitLCD(LANDSCAPE); // Inicializar pantyalla LCD
Pantalla.clrScr(); // Borra la pantalla
Tactil.InitTouch(LANDSCAPE); // Inicializar tactil
Tactil.setPrecision(PREC_MEDIUM);
//Tactil.setPrecision(PREC_HI);
Pantalla.setFont(SmallFont); // Fuente pequeña
Pantalla.setColor(0,0,255); // Color azul
Pantalla.setBackColor(0,0,0); // Fondo negro
Pantalla.drawRoundRect (0,0,799,479);
}
void loop()
{
Tactil.read(); // Obtener cCoordenada pulsada
X=Tactil.getX(); // Coordenada x
Y=Tactil.getY(); // Coordenada y
if (X>-1)
{
Pantalla.print(" ",100,100);
Pantalla.drawPixel(Y,X);
Pantalla.printNumI(X,100,100);
}
}
La pantalla funciona correctamente, pero el sensor tactil no coinciden las coordenadas que lee con las reales.
saque una foto de la pantalla, para intentar explicarme mejor. El programa que le cargue pone un pixel en la coordenada que recibe el sensor tactil, y pasando por el borde de la pantalla esto es lo que aparece:
Nadie tiene idea de lo que puede estar pasando?
Ya me empiezo a preocupar =(
Hola.
Como suelo comenzar casi todos mis post, reitero que no soy muy docto en hardware, pero entiendo que, efectivamente no tienen por qué coincidir las coordenadas de la pantalla con las del sensor táctil, pues son al fin y al cabo dispositivos independientes. Por ello muchos dispositivos que usan pantalla táctil solían tener una aplicación para calibración (ahora no suele ser tan visible, supongo que porque habrá mejorado la tecnología en ese aspecto y vienen mejor colocadas).
La solución, supongo que será mapear por software esas coordenadas respecto a las de la pantalla (función map).
Buenas noter, y muchas gracias por tu respuesta (la primera en tres meses =( )
Creo que el tema tiene algo que ver con la calibración de la misma, ya intente mapear, y el resultado me desconcertó mas todavia
Pantalla X,Y : 0,0 - 800,480
Sensor táctil X,Y : 1,1 - 239,316
La pantalla esta configurada con LANDSCAPE, y el sensor táctil también, aun que da la impresión, que el sensor esta en vertical, y sobre la escala no te quiero ni contar.
He probado a calibrarla, y si uso los valores que me da la calibración , entonces el sensor táctil da unos valores ilogicos
Lo primero, deberías tener claro qué coordenada del táctil correspondería a qué coordenada de la pantalla. Después, deberás mapear las coordenadas obtenidas en el táctil a los valores de la pantalla. Puede darse el caso, incluso, de que las coordenadas estén intercambiadas o crezcan en sentidos opuestos.
¿Si trazas una diagonal desde arriba-izquierda hasta abajo-derecha, en la pantalla se va dibujando en la misma dirección y sentido?
Si fuera así, tendrías que obtener la coordenada de pantalla más o menos así, partiendo de tus números:
pantallax=map(x,1,239,0,800);
pantallay=map(y,1,316,0,480);
Si la diagonal se dibuja siguiendo otra dirección, habrá que intercambiar coordenadas de los mapeos, o tal vez cambiar la configuración del táctil a vertical, en lugar de LANDSCAPE.
Tengo el montaje en la oficina, el lunes pruebo y te cuento.
Las coordenadas crecen al sentido que deben, conseguí hacer algo que medio funciona calculando el valor que deveria tener la coordenada, en vez del que tiene: Y=800*Y/320; X=...
Con eso consigo que el pixel valla a donde tiene que ir, pero pierde un monton de precision.
Exacto. La función map hace eso mismo. tal vez ganes algo de precisión, aunque donde no hay no se puede sacar. Si tu touch tiene 239 puntos de ancho y la pantalla 800, pues digamos que cada punto en el táctil abarcará unos 4 pixels de la pantalla. Lo que me resulta curioso es que en vertical tenga más resolución, pues serían 316 por 480, es decir, casi un pixel de pantalla por pixel táctil.
Eso fue lo que mas me desconcertó, da la impresión que el sensor táctil esta en vertical y la pantalla en apaisado, probé a configurar la en vertical, pero el resultado fue nefasto.
Puede ser problema del shield de la pantalla?, no estoy usando la de itead
Uff. Ahí entramos en terrenos farragosos para mí. No sabría contestarte :~. Puede que la táctil sencillamente tenga más resolución en un eje que en el otro.
Otra posibilidad, el calibrado.
He intentado calibrarlo, pero al introducir los valores que da el programa de calibrado en el fichero utuch.cd el sensor deja de dar valores coherentes, es posible que haya que cambiar algo en el código para adaptarlo 800x480 o de vertical a horizontal o algo asi, no investigue nada al respecto.
Tengo un proyecto en mente que necesita una pantalla de 7¨, e la de 5 tiene la misma resolución, as que con esta (que me han prestado) puedo ir probando ... en cuanto funcione, jejeje
tras horas e intentos, ... eureca lo encontre.
Esto ha sido un cumulo de demostraciones de la ley de Murphi.
El único problema es que la pantalla no estaba bien calibrada, pero :
-Los pines de conexión no son los mismos que los de la tarjeta de itead studio
-El programa que entrega la libraría utuch para calibrar, HAY que indicar bien el modelo, y los pines.
-Hay que tener en cuenta, que las pantallas de 5" solo soportan landcape, y el programa de calibrar define la pantalla cono portrail (este fue mi principal error)
- y sobre todo... (al que se ria lo denuncio) ... los valores que te da la pantalla no hay quien los lea, camiar lo para que los saque por el puerto serial, y la tontería mas gorda en el fichero UTouchCD.h, donde tienes que modificar los datos de calibracion, yo vi esto :
#define CAL_X 0x00378F66UL
#define CAL_Y 0x03C34155UL
#define CAL_S 0x000EF13FUL
Las letras UL no me parecían hexadecimal, así que las conserve ... MAL ECHO.
PD. Mi mas profundo agradecimiento al Sr. Noter, por sus desvelos.
Enhorabuena por el logro.
Seguramente ya sabrás qué significa el sufijo ul y cuándo es necesario ponerlo.
( Hay que mirar el lado positivo de las cosas, incluso cuando nos han vuelto locos :D)
Te agradecería una aclaración al respecto, no se me ocurrió mirar que era es sufijo, solo probé a sacrlo 
Mi nanoconocimiento de C es escaso 
, cuando yo estudie informática (años aquellos en que las ruedas eran cuadradas) aun que C ya existía, yo di informática de gestión , esto es cobol, dbase,foxbase,sql y a capricho basic, y nociones elementales de ensamblador.
Y a mis años me empeñe en aprender c, ... y consigue sorprenderme a diario.
¡Espera un momento!
Creí que el error se había producido precisamente por lo contrario, es decir, por quitarlo. El sufijo UL significa que estás definiendo un unsigned long.
No sé si finalmente suprimirlo ha sido parte de la solución o, sencillamente, no ha influido (al no ser los números mayores a 0x0FFFFFFF); pero me cuesta creer que quien escribiera el código de la librería no tuviera claro si esas constantes deben llevar o no signo.
UTouchCD.h original:
#define CAL_X 0x00378F66UL
#define CAL_Y 0x03C34155UL
#define CAL_S 0x000EF13FUL
UTouchCD.h editado:
#define CAL_X 0x00174FB3
#define CAL_Y 0x00414F4E
#define CAL_S 0x8031F1DF
No tengo claro si el error eran los valores o el sufijo, pero probare a ponerle el sufijo de nuevo y ya te contare
No vi diferencia entre ponerle y no ponerle el sufijo
Bueno. Sea como fuere, bien está lo que bien acaba 
Enhorabuena.
Bueno, una vez funcionando, hay que sacarle el polvo a la pantalla. Acabe una par de funciones para manejar botones, por si alguien le interesa la cuelgo, esta pensada para hacer menus de botones con comodidad.
este pinta los botones
// ***************************************************************************************************************
// ***************************************************************************************************************
// *** DIBUJA MARCO Y BOTONES EN EL,CENTRA HORIZONTAL Y VERTICAL MENTE TANTO EL BOTON COMO EL CARTE DEL MISMO ***
// *** Parametros: ***
// *** MarcoX1, MarcoX2, MarcoX2, MarcoY2 coordenadas x e y del marco destiando a los botones (area a limpiar) ***
// *** Texto[] vector con los nombres a poner en los botones (no controla que la cantidad coincida) ***
// *** Fuente Fuente a usr para e texto del boton 8x12 16x16 (1 o 2) ***
// *** Filas, Columnas Numero de filas y columnas de botones a pintar ***
// *** Separacion separacion minima entre marcos y botones ***
// *** No controla que el texto coja en el boton ni que los botones cojan en el marco ***
// *** Ojo, controlar color, color fondo y fuente al regresar ***
// ***************************************************************************************************************
// *********************************************************************** // *************************************
void PintaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion)
{
int X1,Y1,X2,Y2; // Coordenadas iniciales de cada boton y de cada texto
int tX,tY; // Dimension x e y del botones
int Tx,Ty; // Dimensiones x e y de cada texto
int Cartel=0; // Contador para carteles de boton
Pantalla.setBackColor(0,0,0); // Fondo negro
Pantalla.setColor(0,0,0); // Color negro
Pantalla.fillRoundRect (MarcoX1, MarcoY1, MarcoX2, MarcoY2); // Borrar sitio botones
Pantalla.setColor(255,255,255); // Color blanco
Pantalla.drawRoundRect (MarcoX1, MarcoY1, MarcoX2, MarcoY2); // Marco de botones
tX=((MarcoX2-MarcoX1) - (Filas + 1)*Separacion) / Filas; // Longitud X de los botones
tY=((MarcoY2-MarcoY1) - (Columnas + 1)*Separacion) / Columnas; // Longitud Y de los botones
for (int C=0; C<Columnas; C++) // Recorrer columnas
{
Y1= MarcoY1 + Separacion + ( tY + Separacion ) * C; // Calcular coordenada Y1
for (int F=0; F<Filas; F++) // Recorrer filas
{
X1= MarcoX1 + Separacion + ( tX + Separacion ) * F; // Calcular coordenada X1
Pantalla.drawRoundRect(X1, Y1, X1+tX, Y1+tY); // Contorno boton
Pantalla.setColor(0,0,255); // Color verde
Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3); // Marco ineriore de boton
Pantalla.setColor(255,255,255); // Color blanco
Pantalla.drawRoundRect(X1+4, Y1+4, X1+tX-4, Y1+tY-4); // Marco ineriore de boton
if (Fuente==1) // Fuente pequeña
{
Pantalla.setFont(SmallFont); // Establecer fuente
Tx=8*Texto[Cartel].length(); // Tamaño X cartel
Ty=12; // Tamaño y cartel
}
else // Fuente mediana
{
Pantalla.setFont(BigFont); // Establecer fuente
Tx=16*Texto[Cartel].length(); // Tamaño X cartel
Ty=16; // Tamaño y cartel
}
Pantalla.print(Texto[Cartel],X1 + (tX-Tx)/2 ,Y1+(tY/2)-(Ty/2) ); // Poner el cartel centrado al boton
Cartel++; // Siguiente cartel
}
}
}
Alguien me puede decir si es posible meter en una estructura o en una variable todos los parametros para hacer la escritura mas facil?
void PintaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion)
Y este comprueba cual pulsas
// ***************************************************************************************************************
// ***************************************************************************************************************
// *** COMPRUEBA QUE SI HAY PULSACION EL EL SENSOR TACTIL Y RETORNA EN NUMERO DEL BOTON AL QUE CORRESPONDE O 0 ***
// *** Parametros: ***
// *** MarcoX1, MarcoX2, MarcoX2, MarcoY2 coordenadas x e y del marco destiando a los botones ***
// *** Filas, Columnas Numero de filas y columnas de botones a pintar ***
// *** Separacion separacion minima entre marcos y botones ***
// *** MODO: 1 = Destello continuo hasta soltar, 2 = un destello completo y se sale, 3 = un solo destello ***
// *** Ojo, controlar color, color fondo al regresar ***
// ***************************************************************************************************************
// *********************************************************************** // *************************************
int ChequeaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, int Filas, int Columnas, int Separacion, int Modo )
{
int PX,PY; // Coordenadas Pulsadas
int X1,Y1,X2,Y2; // Coordenadas iniciales de cada boton y de cada texto
int tX,tY; // Dimension x e y del botones
int Rojo=255; // Color del marco boton
int Opc=0; // Numero de boton pulsado
Tactil.read(); // Obtener Coordenada pulsada
PX=Tactil.getX(); // Coordenada x
PY=Tactil.getY(); // Coordenada y
if (PX>-1 && PY>-1) // Hay coordenada pulsada
{
tX=((MarcoX2-MarcoX1) - (Filas + 1)*Separacion) / Filas; // Longitud X de los botones
tY=((MarcoY2-MarcoY1) - (Columnas + 1)*Separacion) / Columnas; // Longitud Y de los botones
for (int C=0; C<Columnas; C++) // Recorrer columnas
{
Y1= MarcoY1 + Separacion + ( tY + Separacion ) * C; // Calcular coordenada Y1
for (int F=0; F<Filas; F++) // Recorrer filas
{
X1= MarcoX1 + Separacion + ( tX + Separacion ) * F; // Calcular coordenada X1
if (PX>=X1 && PX<=X1+tX && PY>=Y1 && PY<=Y1+tY) // Pinchamos dentro de un boton
{
while (Tactil.dataAvailable() && Rojo>0) // Mientras mantenemos pulsado y hay color
{
Pantalla.setColor(Rojo,0,0); // Color rojo variable en funcion del tiempo
Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3); // Marco ineriore de boton
Rojo=Rojo-10; // Bajando intensidad rojo
if (Modo==3) {Rojo=-1;} // Modo 3 solo pinta 1 vez marco
else if (Modo==1 && Rojo<1){Rojo=255;} // Modo 1 Destello continuo, modo 2 para solo con rojo<0
}
Pantalla.setColor(0,0,255); // color azul
Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2); // Marco ineriore de boton
Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3); // Marco ineriore de boton
Pantalla.setColor(255,255,255); // color blanco
Opc= C*Filas + F + 1; // Boton pulsado
F=Filas+1; // Finalizar bucle filas
C=Columnas+1; // Finalizar bucle columnas
}
}
}
}
return Opc;
}