ITDB02 5.0 Y UTouch

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

:disappointed_relieved:

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 :blush:

Mi nanoconocimiento de C es escaso :grin:, 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 :wink:
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;  
}