Go Down

Topic: Algunos consejos para usar TFT´s (Read 57669 times) previous topic - next topic

TFTLCDCyg

Sep 10, 2015, 12:41 am Last Edit: Sep 10, 2015, 12:52 am by TFTLCDCyg
No pretendo crear una guía, solo quiero compartir lo que he aprendido al urgar entre las muchas lineas de código que suben los compañeros al foro. A sugerencia de surbyte, creo este hilo con la idea de que entre todos le saquemos todo el provecho posible a las pantallas TFT.

Advierto que habrá aspectos que bien se podrían resolver con lineas de código mejor optimizadas o depuradas, debo decir que soy un fan de la electrónica y no me considero un erudito, asi que toda crítica constructiva, será bien aprovechada.

Las librerías que he usado por orden de importancia son FTDI (FT800 de FTDI), ILI9341_due (me inclino por la versión 094 ), ILI9341 (Adafruit), TFTLCD (Adafruit), UTFT. Me gustaría manejar la librería ILI9341_t3 (teensy) o la desarollada para el gameduino2, pero ya veremos. Las que me parecen mas complicadas son: TFTLCD y ILI9341_due

Presentación de valores numéricos

Una de las primeras cosas que queremos ver en nuestra flamante pantalla TFT, es el valor de algun sensor de temperatura o de un acelerómetro, un voltaje, las RPM´s de algun motor, el ángulo de un servo, los datos de un GPS, etc, etc; casi siempre se vuelve un dolor de cabeza cuando vemos que lo que mandamos a la pantalla o se sobreescribe, presenta residuos de caracteres o bien en el mejor de los casos tiene un efecto parpadeante, y nos deja a medias con el gusto inicial.

El mejor camino es convertir el valor numérico en una cadena de caracteres; casi todas las librerías tienen muy bien optimizada esta parte.

El primer paso es definir una variable tipo char, con una sola basta para presentar todos los valores en un proyecto.

Code: [Select]
char TX[50];
Dentro del loop en el que se presentarán los datos en pantalla, convertimos el valor numérico en una cadena de caracteres mediante la instrucción sprint. Esta conversión funciona con valores enteros, aunque bien podría funcionar con numeros float, he visto que se obtiene un "?" como resultado. Dado que el resultado es una cadena, podemos dar el formato que deseemos, dependiendo del tipo de fuente, podemos incluso insertar símbolos o letras, Acá algunos ejemplos

Número con tres decimales "000"
Code: [Select]
sprintf(TX,"%03d", Valorslider);

Número con dos decimales, espacio y letras:
Code: [Select]
sprintf(TX,"%03d C", Valorslider);

Número con compuesto por varios datos:
Code: [Select]
sprintf(TX,"%02d:%02d:%02d", hh, mm, ss);

La ventaja de complementar con un cero las posiciones a la izquierda del dato es que los números no se encimarán o dejarán pixeles remanentes.

Bien pueden usarse expresiones como estas: %2d, en las que no se dibujan ceros en las posiciones libres a la izquierda, habrá que probar cual de las dos opciones da el mejor resultado, ya que algunas librerias centran por default los caracteres y dejan pixeles de los caracteres previos. Las librerias derivadas de la adafruit_ILI9341 responden mejor con el formato %02d, el %2d deja residuos.

Otro problema que es culpable de pixeles remanentes, tiene que ver con el diseño de la propia fuente, en teoría todos los caracteres deben tener dimensiones idénticas, es decir altura y ancho común, esto da como resultado que los caracteres se sobreescriban sin dejar residuos, cuando alguno de ellos no coincide en medidas, tiende a dejar residuos. La solución es crear una fuente personalizada o bien que la propia libreria tenga la posibilidad de insertar espacios adicionales entre caracteres.

Con la libreria TFTLCD ambos formatos funcionan sin problemas. Ejemplo:

Code: [Select]
    int T = random(90,110);
     sprintf(TX,"%3d C", T);
     tft.setCursor(137, 50);
     tft.setTextColor(YELLOW, BLACK);  tft.setTextSize(3);
     tft.println(TX);  
  
  
     int TDInt = random(95,115); //simula los datos del sensor
     int fracc = random (0,99);    //simula los datos del sensor
     sprintf(TX,"%3d.%02d C", TDInt, fracc);
     tft.setCursor(85, 100);
     tft.setTextColor(YELLOW, BLACK);  tft.setTextSize(3);
     tft.println(TX);          
    

Code in action


Ejemplo con la librería ILI9341_due (v 094)

Code: [Select]
t3.defineArea(0, 0, 319, 239);
t3.selectFont(Arial14);  
t3.setFontLetterSpacing(2);

   unsigned long currentMillis1 = millis();        
   if(currentMillis1 - previousMillis1 > 2000)
    {
       previousMillis1 = currentMillis1;  
       lecturaV = random(0,1023);  //simula los datos del sensor
      
       Volumen = map(lecturaV,0,1023,0,100);
       sprintf(TX,"Lectura = %04d  (%03d ml)", lecturaV, Volumen);
       t3.setFontColor(WHITE, ILI9341_BLACK);
       t3.drawString(TX,80,50);
    } //usa millis en lugar de delay



Las librerias UTFT y FTDI, cuentan con instrucciones que directamente pueden manejar valores numéricos e incluso permiten aplicarles un formato, su uso es bastante simple

Sigue: creación de menus aprovechando la pantalla táctil
ft81xmania.com/comunidad/

Jopapa

Creo que este post (y los prometidos siguientes) es muy interesante y deberías publicarlo en el hilo de documentación.
Jopapa
www.jopapa.me

kilimon

Me has convencido, cuando finalice uno que me esta llevando de cabeza, voy a probar con un tft. Siguiendo este hilo. Parece ser sencillo y con el camino abierto.

Gracias por el aporte.


TFTLCDCyg

#3
Sep 13, 2015, 07:58 am Last Edit: Sep 13, 2015, 08:13 am by TFTLCDCyg
Esperemos que ayude a mas de uno a mejorar sus proyectos, vamos con el siguiente punto.

Creación de menús con la pantalla táctil

La mayoría de TFT´s disponibles tienen pantallas táctiles resistivas. Debo aclarar que existen dos tipos de cableado: uno de ellos fue diseñado para funcionar en el arduino UNO y emplea cuatro hilos generalmente dos pines analógicos y dos pines digitales, resulta algo confuso ponerlo a punto ya que hay que asignar manualmente y por prueba y error el valor de la resistencia de referencia de la pantalla táctil. Usan chips tanto XPT2046 como STMPE610, su funcionamiento es complejo y aun hoy no he podido llegar a conocerlos bien.

La otra variante en la que se conecta el XPT2046, emplea 5 lineas: TCLK, TCS, TDIN, TDOUT, IRQ. A pesar de que el nombre de cada pin podría señalar a la pantalla táctil como un dispositivo SPI, esto no es así, gracias a la librería Utouch diseñada por Henning Karlsen, la pantalla puede ser controlada por completo con pines digitales. En el Due o MEGA se puede usar cualquiera de ellos. No es necesario el empleo de conversores lógicos 5-3.3 V, ya que la pantalla se comporta igual tanto en arduinos como el UNO o MEGA, e incluso el Due.



No he podido conseguir TFT con pantallas táctiles capacitivas, aun tengo mucho por aprender de ellas.
Me centraré en pantallas con chip XPT2046 y 5 hilos. Asumiré que ya tenemos la tripleta de calibración que podemos conseguir del ejemplo Utouch_Calibration.



Para usar la pantalla táctil dentro de un sketch, las lineas de código básicas son

Inicio del encabezado
Code: [Select]
#include <UTouch.h>   // touch lib   XPT2046

Antes de la definición de variables generales
Code: [Select]
//touch panel (TCLK, TCS, TDIN, TDOUT, IRQ)
UTouch  myTouch(6,5,4,3,2);


Estas variables generales posibilitarán el acceso a las coordenadas de la pantalla táctil
Code: [Select]
int x, y;

En el setup(), hay que incluir estas lineas:

Code: [Select]
   myTouch.InitTouch();
    myTouch.setPrecision(PREC_HI);


Hay 4 modos para esta linea: LOW, MEDIUM, HI y EXTREME, la que mejor se comporta es la HI.

La mejor forma de usar la pantalla táctil es dividirla en segmentos rectangulares, dentro de bucles de espera que responden al cambio de alguna coordenada xy de la pantalla táctil. De esta forma podemos usar toda la pantalla o solo segmentos de ella.

Sugiero diseñar cada menú como una función independiente, de esta forma  podemos usar la pantalla táctil completa en cada menu, sin que se superpongan secciones táctiles remanentes.

Code: [Select]
void Menubase()
{
    //Instrucciones que solo se usan una vez al activar el menu: fondos de pantalla, valores iniciales de una variable, imagenes BMP, texto inicial, encabezados, distribución de botones.
    
    while (true)
      {

//Instrucciones que llaman secciones de programa que cambian con el tiempo: la hora de un reloj, la lectura de algún sensor, acción con algún led, por ejemplo


        if (myTouch.dataAvailable())
           {

//Instrucciones que dependen de la presión de algún segmento de la pantalla táctil
              myTouch.read();
              x=myTouch.getX();
              y=myTouch.getY();        


//Segmentos de pantalla táctil para accesar a nuevos menús o bien manipular algún deslizador o icono

// MenuX              
        if ((y>=y11) && (y<=y12))
           {      
          if ((x>=x11) && (x<=x12))
             {        
                Redbox24SPI(x11,y11,x12,y12);                
                MenuX();
             }
           }    
//End Menu X

           }

      }
}



Esta función podemos usarla para crear el menu principal y también permite crear todos los menus que necesitemos en el proyecto, usando cualquier parte de la pantalla










Sugiero usar segmentos acotados con valores específicos, con la idea de no cargar de variables cada sketch, en el ejemplo uso variables para cada segmento táctil debido a que me resultó muy cómodo para diseñar menus rápidos.

El dibujo de botones lo podemos lograr usando funciones generales como esta:

Code: [Select]
void button24SPI(int x1, int y1, int x2, int y2, uint16_t color)
{
  tft.fillRoundRect(x1,y1,(x2-x1),(y2-y1),3,color);  
  tft.drawRoundRect(x1,y1,(x2-x1),(y2-y1),3,WHITE);  
}


Para resaltar los botones que pulsamos, recomiendo usar una función indicadora como esta:
Code: [Select]
void Redbox24SPI(int x1, int y1, int x2, int y2)
{
  tft.drawRoundRect(x1,y1,(x2-x1),(y2-y1),3,RED);  
  
  while (myTouch.dataAvailable())
  myTouch.read();
  tft.drawRoundRect(x1,y1,(x2-x1),(y2-y1),3,RED);  
}


Así podremos "tener la sensación de tocar" el botón cuando lo pulsamos

Este es el sketch completo MEGA menu

Funciona con la librería ILI9341_due versión 094, tanto en Due como en MEGA, incluso funciona en el arduino UNO. Las pantallas en las que funciona directamente son estas: ILI9341 2.4" o ILI9341 2.8".



Con algunos ajustes también puede funcionar en pantallas que funcionan con la librería UTFT, como las basadas en el chip SSD1986 o bien ILI9325D/C, ya que casi todas tiene el chip XPT2046 con 5 hilos de control



Funcionamiento de algunos ejemplos:
Calibración de la pantalla táctil
Botón táctil de encendido/apagado de la PC
Menu 1
Menu 2



En la siguiente: diseño de barras deslizantes que funcionan con la pantalla táctil
ft81xmania.com/comunidad/

TFTLCDCyg

Haré una pausa en el diseño de indicadores. La primer TFT que llegó a mis manos fué una pantalla de 2.4" de mcufriend. Nunca pude hacer que la pantalla táctil diera signos de vida.

Me topé con este par de trabajos, en los que un fan de estas pantallas ha trabajo para conseguir que de una vez funcionen tal como nos prometen los vendedores.

TFT en UNO

TFT en MEGA

Modificó con éxito algunas secciones de la librería Adafruit TFTLCD con la idea de poder usar la pantalla, su lector SD y la libreria TouchScreen para activar pantalla táctil que a tantos nos ha costado despertar. También hizo algunos cambios en la libreria SD y me parece que las imagenes BMP se pueden leer de forma estable, solo hay que cuidar que el formato de cada BMP sea de 24 bits.

No ahondaré en la puesta a punto, ambas ligas tienen todo lo necesario para activar el shield. Me parece un logro bastante destacable el hecho de que se puede usar la pantalla conectándola directamente en el MEGA sin modificar nada.

Tomando como base los ejemplos, conseguí aproximar los parámetros para que la calibración de la pantalla táctil se adapte a la rotación 3 del TFT (por default las librerias usan la Rotación 1). Modifiqué los parámetros de ajuste para que la pantalla táctil inicie desde los iconos prediseñados, con la idea de poder usarlos en cualquier parte de un skecth.

La estructura de control que posibilita integrar la función táctil en la libreria Touchscreen, también se puede usar en la libreria Adafruit_STMPE610 que usan algunas pantallas ILI9341 o HX8357

En este caso, la estructura de cada menú tiene las siguientes partes

Instrucciones que solo se cargan una vez al llamar el menu

Code: [Select]

void MenuBlanco()
{
    bmpDraw(imagesOnSDCard1[imagenSD1],0,0);  //o puede ser un tft.fillScreen(0);
    tft.setTextSize(0);             
   
//botones prediseñados   
    button24(ix11, iy11, ix12, iy12, GREEN); //icono casa   
    button24(ix21, iy21, ix22, iy22, GREEN); //icono libro
    button24(ix31, iy31, ix32, iy32, GREEN); //icono correo
    button24(ix41, iy41, ix42, iy42, GREEN); //icono cámara   
    button24(ix51, iy51, ix52, iy52, GREEN); //icono monitor
//botones prediseñados   
    tft.setTextSize(2);
    button24(x21, y21, x22, y22, BLUE);   //Botones diseñados
    tft.setCursor(x21+TextoX,y21+TextoY);  tft.setTextColor(WHITE,BLUE);  tft.println("M P");//Botones diseñados   


Instrucciones que permiten actualizar la lectura de un sensor, un reloj, o monitorear continuamente las entradas táctiles
Code: [Select]
do
     {
        //lecturas que cambian con el tiempo, monitoreo de pantalla táctil
     }
while(1);


Las lineas anteriores, posibilitan que la parte void loop(), permanezca sin usar, llamando los ciclos de todo el sketch desde el  void setup()

Dentro de ellas, se puede colocar la función que se encarga de monitorear las coordenadas de la pantalla táctil y las coordenadas entre las que deseamos que un elemento grafico tenga funciones táctiles.

Code: [Select]
void lecturaPanelTactil()
{
    TSPoint p = ts.getPoint();
    pinMode(XM, OUTPUT);
    pinMode(YP, OUTPUT);
//Rotacion 3
    X = map(p.y, TS_MINX, TS_MAXX, tft.width(), 0);
    Y = map(p.x, TS_MAXY, TS_MINY, tft.height(), 0);
//Rotacion 3
    Z = p.z;
}


Por ejemplo, para el diseño de botones, recomiendo usar una función que sea la encargada de dibujarlos, con esto ahorramos espacio de programación. Por ejemplo

Code: [Select]
//Funcion para dibujar botones
void button24(int x1, int y1, int x2, int y2, uint16_t color)
{
  tft.fillRoundRect(x1,y1,x2,y2,3,color);  //relleno del botón
  tft.drawRoundRect(x1,y1,x2,y2,3,WHITE); //Borde del botón
}


Solo falta definir los segmentos de pantalla táctil que corresponderán a los botones o elementos gráficos que haran alguna acción o llamarán a un nuevo menu. Este es un ejemplo:

Code: [Select]
//boton azul   --- Retorno a menu principal
      if((X > x21+deltaTactil && X < x21+x22+deltaTactil) && (Y > y21 && Y < y21+y22) && (Z > MINPRESSURE && Z < MAXPRESSURE))
        { 
          Serial.print("x= ");
          Serial.print(X);   
          Serial.print("   y= ");           
          Serial.print(Y); 
          Serial.println("   ");
          tft.fillRoundRect(x21, y21, x22, y22,3, RED);
          tft.setCursor(x21+TextoX,y21+TextoY);  tft.setTextColor(WHITE,RED);  tft.println("M P");//Botones diseñados         
          delay(350);
          button24(x21, y21, x22, y22, BLUE);
          tft.setCursor(x21+TextoX,y21+TextoY);  tft.setTextColor(WHITE,BLUE);  tft.println("M P");//Botones diseñados
          MenuP();
        }   
//boton azul   --- Retorno a menu principal


Ejemplo de menus y carga de imagenes en funcionamiento

Sketch e imagenes


ft81xmania.com/comunidad/

TFTLCDCyg

El trabajo me mantiene bastante ocupado, no obstante en los ratos libres he estado aplicado con otra pantalla: un gameduino 2. Recientemente el creador de este proyecto de pantalla, ha liberado la libreria oficial para el arduino Due.

Aunque fué diseñado como un shield para el arduino UNO, el creador del gameduino2 añadío a la librería, la posibilidad de redirigir las señales del cabezal SPI a los pines 11,12 y 13 del arduino Due, por lo que sin ningun problema el shield puede instalarse sobre el arduino Due, tal como se conecta al arduino UNO.

El ángulo de visión de la pantalla que tiene el gameduino es un 60% más estrecho que el ángulo de visión del FT843, no obstante, la velocidad de ambas pantallas para el manejo de gráficos es asombrosa, nada menos que 60 Hz de tasa de refresco. Nada mal, considerando la modesta velocidad de los micros como el UNO o el MEGA.



En la siguiente intervención les compartiré algunos ejemplos de lo que se puede hacer con esta pantallita.

ft81xmania.com/comunidad/

liebherr

Muy buenas TFTLCDCyg, lo primero agradecerte este tema tan interesante que la verdad me ha venido de perlas, y por otra parte te quería preguntar una cosita.

Para el proyecto tengo un DUE, el shield y una pantalla TFT de 5" para la presentación por pantalla utilizo pantallas completas para ver la representación gráfica, mi duda es que no se si se puede que en una parte de la pantalla osea encima dibuje un circulo y luego pueda borrarlo sin que desaparezca la parte de atrás, osea la pantalla que ya estaba puesta.

A ver si puedes darme un poco de luz en este tema, y cuando puedas completar todo lo que dices que estoy seguro que sera cuando menos igual de interesante como hasta ahora.

Saludos.

TFTLCDCyg

#7
Jan 05, 2016, 08:24 am Last Edit: Jan 05, 2016, 08:29 am by TFTLCDCyg
Directamente un TFT en arduino no es capaz de conseguir un efecto gráfico como el que describes, pensando en que todo lo consigas en una sola presentación o un solo paso.

El mecanismo que te sugiero, funciona muy bien a bajas velocidades, es decir que mantengas una presentación cada determinado tiempo. Si deseas algo en tiempo real o alta frecuencia, como digamos algo parecido al video del analizador de espectro en el gameduino 2, en definitiva el equipo que tienes no te va a servir.

Este es el video al que me refiero con el gameduino 2 y el analizador de espectro

El truco que podrías usar consiste en diseñar dos o tres o las "presentaciones" que necesites con la misma imagen de fondo y mediante un botón táctil, ubicado en alguna de las esquinas o bien que que ese botón táctil ocupe toda la pantalla, podrías ir pasando de presentación en presentación.  Cada presentación puede tener botones, o imágenes superpuestas, en el orden que quieras.

El efecto negativo que podrías ver al pasar de una presentación a otra, es el relativo a la velocidad con la que la imagen de fondo se dibuja en la pantalla.

El primer paso es que consigas cargar las imagenes desde el lector SD que debe tener tu pantalla. Para la libreria UTFT lo mejor es que uses la libreria que describen en este post:

http://forum.arduino.cc/index.php?topic=273573.0

Te recomiendo leerlo todo ya que hay varias actualizaciones de la libreria, y lo mejor de todo es que puedes aprender a usarla adecuadamente. Hay que convertir las imagenes a formato RAW, en el post está lo que necesitas saber.

Este es un ejemplo de lo que puedes conseguir, es una pantalla de 2.4" funcionando con la libreria que te sugiero, para UTFT y Sdfat.

Debes calibrar el panel táctil de tu pantalla con la libreria Utouch que viene dentro de UTFT.

Luego debes familiarizarte con el manejo de menus y submenus mediante el uso de la pantalla táctil, esto te ayudará a intercambiar las presentaciones en el orden que mejor te parezca, no necesariamente de forma secuencial.

Con esos 3 pasos debes poder atacar la transición entre presentaciones en tu pantalla.
ft81xmania.com/comunidad/

liebherr

Vaya TFTLCDCyg me has sorprendido con la presentación del gameduino 2, por lo que he visto es un poco caro, pero creo que lo necesito para este proyecto, es una pasada lo que se puede hacer con el.

Lo de las imágenes por la tarjeta SD es lo que estoy haciendo, pero como tu dices en una pantalla de 5" no es lo rápido que se necesita, y ademas crea un efecto desagradable.

A si que si quiero hacer lo que te explicaba ya veo donde tengo que morir.

Supongo que no hay problema para instalar el gameduino en arduino DUE, y entonces puede trabajar conjuntamente con el shield de la TFT? o se puede prescindir de la shield?

Muchísimas gracias, eres un crack del TFT

Saludos.

liebherr

He estado mirando y por lo que veo el gameduino 2 va con la pantalla de 4,3", a si  no se puede poner otra pantalla, osea la que tengo no me sirve para este sistema, y 4,3" la veo un poco pequeña.

Hay algun otro tipo que sea similar que se pueda añadir una pantalla de 5" o de 7"?

La verdad que me gusta como trabaja pero como te digo quizá me resulte un poco pequeña para el sistema que estoy haciendo.

Saludos.

TFTLCDCyg

De hecho decidí adquirir un gameduino2, porque el creador de este shield, a finales del 2015 liberó las librerias que permiten hacerlo funcionar en el arduino Due. Originalmente lo diseño para funcionar en UNO o MEGA.

Otro detalle que me llamó mucho la atención, es que el shield del gameduino2 tal como está, se puede conectar directamente sobre el arduino Due, no hay que hacer cambios físicos. El autor hizo que la libreria transporte las señales del cabezal SPI del arduino Due, a los pines 11, 12 y 13, con esto se evitó modificar su proceso de fabricación, y el shield se puede usar sin problemas.

Asi es como se ve sobre el arduino Due:


Decidí construir una interfase para el gameduino y el arduino Due, porque necesito otros elementos como un DS3231, otro lector micro SD para la gestion de datos, los 4 chips MSGEQ7, este es el cable y las dos placas de interfase


ft81xmania.com/comunidad/

TFTLCDCyg

#11
Jan 05, 2016, 03:38 pm Last Edit: Jan 05, 2016, 03:44 pm by TFTLCDCyg
Otros tamaños... la libreria del gameduino 2 esta diseñada para manejar la familia de chips FT8XX. El GD2 tiene el chip FT800, de acuerdo con el autor, es posible usar cualquier pantalla que tenga esos chips, pero con algunas limitaciones respecto al tema del acceso al lector SD.

FTDI chip tiene un par de tarjetas de desarrollo con pantallas de 5".

FT800C: VM800C50A-D incluye una pantalla de 5"
FT810C : la placa es VM810C50A-D, incluye una pantalla de 5", con resolución de 800 x 480 px

Ambas opciones se podrían conectar al arduino due y controlarlas mediante a libreria del gameduino 2, pero habría que armar el cableado o la interfase. Bastan 8 hilos para conseguirlo

La desventaja es que no tendrías acceso a la parte de carga de imagenes desde un lector SD, ya que esas tarjetas no tienen el circuito interconectado al chip FT8XX, para tener acceso a la gestion de carga de imagenes.

Un detalle mas que me convenció para decantarme por estas pantallas, es que el FT800 tiene la capacidad para manejar un nivel de pixel de hasta 1/16

Puntos encontra: hay que ajustar el nivel de la retroiluminación a un 92% para que no se perciba que la pantalla se calienta, eso se puede conseguir mediante la propia libreria, dentro del setup. Esto se percibe en el gameduino 2, pero en el FT843 no ocurre.

El ángulo de visión del GD2 es algo reducido, pero no es algo que le reste funcionalidad.

El FT800 tiene un espacio limitado para almacenar información de 256K. Aparentemente es una limitante enorme, pero se puede usar alguna que otra técnica para que no afecte en la práctica

En el FT810 el limite es de 1MB, pero aun no se ha diseñado una placa que incluya un lector SD. Ojalá este año liberen una pantalla así, sería la evolución en este tipo de pantallas para arduino
ft81xmania.com/comunidad/

liebherr

Vaya, cuanto sabes, da gusto hablar contigo, creo que primero probare el gameduino 2 ya que es una pasada.

Me podrías decir algun sitio de confianza para poder comprarlo.

Saludos.


TFTLCDCyg

La diferencia entre 4.3 y 5", no es mucha, estimo que serán un par de lineas de texto. El gameduino 2 sin bisel mide 10.5 x 6.7 cm, tiene una resolución de 480 x 272 px.

Este es uno de los primeros ejemplos que me hicieron investigar el tema de las pantallas basadas en el FT800:

https://www.youtube.com/watch?v=EZ6LWVHtU_Q

Las dos opciones que cubren todas las prestaciones del FT800 son:

- Gameduino 2
- FT843 + ADAM de 4D systems

Ambas tienen habilitado un lector micro SD y cuentan con un amplificador de audio

Estoy haciendo pruebas para adaptar el FT843 para que funcione con la libreria del gameduino 2; de fábrica viene preparado para funcionar con la libreria nativa del FT800, pero es algo pesada, se puede usar pero hay que escribir muchas lineas de codigo.
ft81xmania.com/comunidad/

TFTLCDCyg

Estuve revisando el datasheet del adaptador para arduino del FT843 (ADAM por sus siglas en ingles). El soporte para la tarjeta micro SD tiene el siguiente pinout

Code: [Select]
1         NC
2         SD-CS  (3V3)
3         MOSI   (3V3)
4         3.3 V
5         SCK    (3V3)
6         GND
7         MISO   (3V3)  
8         NC


Solo hay un condensador cerámico de 4.7 uF conectado entre Vcc y tierra.

De acuerdo con el datasheet del adaptador microSD (que recomienda mikroe para usarse en sus placas), el condensador cerámico puede eliminarse. Esta observación también aparece en el datasheet del breakout microSD de Sparkfun. Ambos adaptadores señalan que se deben alimentar con 3.3V exclusivamente. En dispositivos de 5V deben usarse divisores de voltaje o circuitos como el CD4050BE.

Así que puedo suponer que es factible usar un adaptador micro SD de 3.3V para agregarlo a dispositivos FT800 que no tienen esa opción de fábrica. Es muy posible que se pueda usar la libreria del GD2 en placas de desarrollo como el VM810C50A-D o el VM800C50A-D, agregandoles soporte para carga de imagenes.

Me llama mucho la atención la placa VM810C50A-D, pues el FT810 tiene 1M de memoria interna, que es 4 veces mas grande que la que tiene el FT800 como el gameduino2 o el FT843.

Pedí unos lectores micro SD de 3.3V, para hacer pruebas con el FT843 en cuanto termine de construir el adaptador. El lector microSD es este:

http://www.lctech-inc.com/Hardware/Detail.aspx?id=27e765c5-7052-46d7-846b-338e6b74495b
ft81xmania.com/comunidad/

Go Up