Arduino Forum

International => Español => Hardware => Topic started by: TFTLCDCyg on Sep 10, 2015, 12:41 am

Title: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 10, 2015, 12:41 am
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 (https://www.youtube.com/watch?v=Q-5ipWtA7cg)
(http://www.mediafire.com/convkey/e56d/pya4dmmjzep4kkvzg.jpg)

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

(http://www.mediafire.com/convkey/0bee/vdwmlqtwtb6vcz6zg.jpg)

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
Title: Re: Algunos consejos para usar TFT´s
Post by: Jopapa on Sep 10, 2015, 12:33 pm
Creo que este post (y los prometidos siguientes) es muy interesante y deberías publicarlo en el hilo de documentación.
Title: Re: Algunos consejos para usar TFT´s
Post by: kilimon on Sep 12, 2015, 08:14 pm
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.

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 13, 2015, 07:58 am
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.

(http://www.mediafire.com/convkey/cf85/0155bsu9y1w5kw2zg.jpg)

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.

(http://www.mediafire.com/convkey/3299/f9lh4khaup4ghiazg.jpg)

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

(http://www.mediafire.com/convkey/a352/n8zbwspfclkd9jkzg.jpg)

(http://www.mediafire.com/convkey/e9b7/k796blrb58uu496zg.jpg)

(http://www.mediafire.com/convkey/960d/ixklaf5hpgxfc21zg.jpg)

(http://www.mediafire.com/convkey/887a/9akaqn9mbhidlamzg.jpg)


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 (http://www.mediafire.com/download/tsaensso8so2lcc/MEGA_menu.rar)

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".

(http://www.mediafire.com/convkey/0a52/mgm179ephh8l8y5zg.jpg)

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

(http://www.mediafire.com/convkey/6d99/h64eeo345vup72vzg.jpg)

Funcionamiento de algunos ejemplos:
Calibración de la pantalla táctil  (https://www.youtube.com/watch?v=G94iX3mNiPU)
Botón táctil de encendido/apagado de la PC (https://www.youtube.com/watch?v=7J4q7CZ0WA8)
Menu 1 (https://www.youtube.com/watch?v=zH-H5ND8DCA)
Menu 2 (https://www.youtube.com/watch?v=jeIIPOPkX4E)



En la siguiente: diseño de barras deslizantes que funcionan con la pantalla táctil
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Oct 05, 2015, 07:09 pm
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 (http://electronicavm.net/2015/03/05/tft-lcd-touch-2-4-shield-para-arduino-uno/)

TFT en MEGA (http://electronicavm.net/2015/05/27/tft-lcd-touch-2-4-shield-para-arduino-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 (https://www.youtube.com/watch?v=2Agni9t-pUU)

Sketch e imagenes (http://www.mediafire.com/download/hb9pjpng3owcu2a/TFT_Menu.rar)

(http://www.mediafire.com/convkey/08a3/vkwd1q1jcyd3nmqzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 14, 2015, 08:13 am
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.

(http://www.mediafire.com/convkey/46e0/gb2m1qu6u3oo45jzg.jpg)

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

Title: Re: Algunos consejos para usar TFT´s
Post by: liebherr on Jan 04, 2016, 06:48 pm
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.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 05, 2016, 08:24 am
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 (https://www.youtube.com/watch?v=9EpHpJ_IkVI)

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 (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 (https://www.youtube.com/watch?v=LBm36nM-kK4), 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.
Title: Re: Algunos consejos para usar TFT´s
Post by: liebherr on Jan 05, 2016, 01:04 pm
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.
Title: Re: Algunos consejos para usar TFT´s
Post by: liebherr on Jan 05, 2016, 03:12 pm
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.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 05, 2016, 03:15 pm
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:
(http://www.mediafire.com/convkey/3dde/fc39eiw1cxqckyfzg.jpg)

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
(http://www.mediafire.com/convkey/2252/8iocd88xpx59q5vzg.jpg)

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 05, 2016, 03:38 pm
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
Title: Re: Algunos consejos para usar TFT´s
Post by: liebherr on Jan 05, 2016, 06:42 pm
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.

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 05, 2016, 10:50 pm
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 (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.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 06, 2016, 03:03 pm
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 (http://www.lctech-inc.com/Hardware/Detail.aspx?id=27e765c5-7052-46d7-846b-338e6b74495b)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 17, 2016, 07:21 pm
He estado construyendo un controlador de ventiladores para la PC, exploré varias opciones para añadirle un TFT táctil, di con el FT843 y me pareció la mejor opción, solo que me ha tomado mucho tiempo familiarizarme con su librería de control y no he podido llegar ni a la mitad de su potencial. Me llamó la atención el gameduino 2, sobre todo su librería, que me parece tiene un alto grado de optimización, tomando como referencia la librería original diseñada para el FT800.

Aun tengo pendiente el tema de la alimentación eléctrica para los ventuiladores, por lo que ese apartado lo tengo en pausa.

La semana pasada llegaron los lectores micro SD:
(http://www.mediafire.com/convkey/c7f9/1n87j8740e1g0y5zg.jpg)

Dediqué un tiempo para construir un adaptador para conseguir que el FT843 admita el control con la librería GD2. Encontré que la distancia del cableado entre el ADAM y la pantalla no debe ser mayor a 23 cm, mas allá de esa distancia la pantalla no da señales de vida.

Dejé una distancia total de 18 cms
(http://www.mediafire.com/convkey/7a87/zcoa2pdzmz1zvbtzg.jpg)

Opté por ensamblar un módulo lateral sobre el ADAM, ya que conectaré dos spectrum shields. El cableado lo manejé con cable plano de 10 hilos, de esta forma no habrá que lidiar con una veintena de hilos.
(http://www.mediafire.com/convkey/2a6b/yg6lxgjxqbc454pzg.jpg)

Con el lector micro SD también hay que cuidar la distancia del cable de interconexión, ya que mas allá de 15 cms el lector deja de funcionar. Opté por dejarlo en una distancia de 11 cms. La idea es poder colocar una ranura en el frontal del controlador, para tener acceso a la tarjeta micro SD sin tener que desmontar todo el dispositivo del gabinete de la PC.
(http://www.mediafire.com/convkey/c7bf/84y81g8dud54cn4zg.jpg)

Los lectores micro SD funcionan a 3V3, de los 6 que llegaron, 3 de ellos no funcionaron correctamente, y 3 si que respondieron como esperaba.

Por fin pude probar todo en conjunto: la libreria GD2, el lector microSD externo y el FT843/ADAM...
(http://www.mediafire.com/convkey/9bbc/ac2libardzt5zmqzg.jpg)

Un par de videos como muestra: modifiqué algunos ejemplos que vienen en la libreria GD2 para poder usarlos dentro del programa del controlador.
https://www.youtube.com/watch?v=pf9U5C5TH90 (https://www.youtube.com/watch?v=pf9U5C5TH90)

La libreria neomatrix de adafruit, tiene una instrucción llamada swipe, que entra en conflicto con la libreria GD2, ya que esta tiene también una instrucción llamada swipe. La solución fué bastante simple, solo renombré swipe por swipe1 en la libreria neomatrix.

https://www.youtube.com/watch?v=db2fyZ-zBHU (https://www.youtube.com/watch?v=db2fyZ-zBHU)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 21, 2016, 09:38 pm
En lo sucesivo trataré de ir subiendo aspectos generales para el manejo de la libreria GD2.

Proyecto: menu con iconos y fondo de pantalla

Objetivos:

- Aprender a crear assets de imagenes
- Usar la pantalla táctil
- Aprender a crear menus interactivos

Cada presentación que se diseña en el FT800, está limitada a los 256 kb de memoria gráfica que tiene el chip, superando ese limite, el TFT deja de funcionar y nos recompensa con un "pantallazo azul"
(http://www.mediafire.com/convkey/1471/ujnp7pl45674jojzg.jpg)

Si alguna instrucción está incompleta en su estructura, aunque el IDE nos señale que el sketch no presenta errores, al activarla en pantalla también se mostrará el mensaje con fondo azul. Esto ocurre cuando se desborda una variable o colocamos una instrucción que depende de otra, como por ejemplo llamar una imagen que no hemos cargado en el FT800 previamente.

Paso 1: creación de un set de iconos

Muchas veces queremos usar un grupo de iconos y asociarlos al manejo de menus dentro de un sketch. Hay pantallas que ya vienen con un set de iconos y de fuentes precargados, que podemos usar al diseñar un proyecto. Paro aun con esa bondad estamos sujetos a los iconos y fuentes que el fabricante quiso colocar en su hardware y no hay de otra que sujetarnos a ellos. Aun así son muy contadas las pantallas que pueden hacer esto, en la gran mayoría de TFT´s disponibles para arduino, hay que ingeniárselas con imagenes bmp, raw o jpg.

Otro aspecto que he observado, es que no es posible manejar transparencias y debemos ajustar el diseño a iconos rectangulares o cuadrados, empleando una máscara de fondo para simular una transparencia.

En la libreria GD2, es posible crear arreglos o sets de iconos en formato png y aprovechar los fondos transparentes que se pueden manejar en ese tipo de archivos de imagen.

Cada set de iconos está limitado a 15 archivos de imagen individuales por cada pantalla que diseñemos, sin embargo es posible contar con varios de estos arreglos dentro de un mismo sketch y lo mejor de todo: activarlos en pantalla solo cuando los necesitemos, evitando llegar al limite de los 256 kb de la memoria gráfica del FT800.

Sugiero diseñar arreglos de 14 iconos, reservando el último espacio de memoria para el archivo de imagen que usaremos como fondo de pantalla.

La herramienta que nos permitirá obtener el arreglo de iconos se llama: gd2asset (http://www.mediafire.com/download/bqxlh0ncdo62pwe/GD2asset.zip). Es un archivo que funciona desde la linea de comandos de windows.

PD: el tiempo apremia, hay que retomar el trabajo, mas tarde continúo.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 23, 2016, 12:02 am
El gd2asset permite convertir grupos de hasta 15 imágenes en formatos jpg, bmp y png. También es posible convertir archivos de fuente en formato ttf.

Se pueden ajustar parámetros en la linea de comando tales como resolución en imágenes, o tamaño de letra, en archivos de fuentes.
(http://www.mediafire.com/convkey/aa91/2uuw9wj3xhcd1dfzg.jpg)

En el caso que nos ocupa, usaré algunos íconos en formato png de 48x48 px, del set de iconos denominado Oxígen Iconset, creado por KDE (https://www.kde.org/), son de uso público (política de uso (http://www.gnu.org/licenses/lgpl-3.0.txt))

Reunimos todos los archivos de los iconos dentro de la carpeta donde están los archivos del gd2asset.exe; abrimos la consola de comandos e ingresamos a la carpeta indicada. Sugiero que la ruta sea esta:
Code: [Select]
C:\GD2asset
Así evitamos algún conflicto en la conversión de archivos. Recomiendo asignar nombres cortos para que la captura de nombres no se vuelva tediosa, lo mas simple es un prefijo hecho con letras, seguido de un numero consecutivo. En cada set de iconos debemos usar prefijos diferentes para evitar conflictos de lectura dentro del sketch.

Ingresamos la siguiente linea de comando:
Code: [Select]
gd2asset -f nombre.gd2 -o nombre.h icono0.png icono1.png ...  icono13.png

Se crearan 2 archivos: nombre.gd2 y nombre.h. El primero (*.gd2) se debe guardar en la microSD y el segundo (*.h), va dentro de la carpeta que contiene el sketch en el que deseamos usar los iconos. Estos dos archivos forman cada asset.

El nombre de archivo debe iniciar con una letra y tener una longitud máxima de 8 caracteres. No es necesario copiar los archivos fuente de los iconos, ya que toda la información necesaria va dentro de los dos archivos generados por el conversor.

En este caso no aplicaré ningún formato de salida en las imágenes del archivo de íconos.
(http://www.mediafire.com/convkey/7078/4hv7spyb87v6877zg.jpg)

El espacio de memoria requerido en el FT800 se muestra en el reporte de conversión como GD2 RAM used, en este caso el set de iconos ocupa 60.184 Kb.

Uso del asset en pantalla

Para cargar el contenido de un archivo de asset debemos usar la siguiente secuencia de instrucciones:

Code: [Select]
//22012016
#include <SPI.h>
#include <GD2.h>

#include "Icons2.h"

void setup() {
  GD.begin();
   LOAD_ASSETS();
}

void loop() {
  GD.Clear(); 
  GD.Begin(BITMAPS);
    GD.Vertex2ii(0, 0, 0);
    GD.Vertex2ii(0, 48, 1);
    GD.Vertex2ii(0, 96, 2);
    GD.Vertex2ii(0, 144, 3);
    GD.Vertex2ii(0, 192, 4);
    GD.Vertex2ii(60, 0, 5);
    GD.Vertex2ii(60, 48, 6);
    GD.Vertex2ii(60, 96, 7);
    GD.Vertex2ii(60, 144, 8);
    GD.Vertex2ii(60, 192, 9);
    GD.Vertex2ii(120, 0, 10);
    GD.Vertex2ii(120, 48, 11);
    GD.Vertex2ii(120, 96, 12);
    GD.Vertex2ii(120, 144, 13);
  GD.swap();
}


Este es el resultado:
(http://www.mediafire.com/convkey/bbdf/d0xjj97mwvy3yqezg.jpg)
El FT800 no funciona como los demás controladores disponibles en TFT´s para arduino, es un procesador gráfico que proporciona a la pantalla una tasa de refresco máxima de 60 Hz, así que no veremos pantallas con parpadeos o residuos de pixeles; siempre y cuando cada diseño de pantalla no supere los 256 Kb.

El asset tiene 14 iconos individuales, cada ícono se coloca dentro de un espacio de memoria reservado, el FT800 dispone de 15 espacios de este tipo. Generalmente reservo el último espacio para el archivo de imagen que funciona como fondo de pantalla.

El archivo .h de cada asset, por default tiene esta instrucción que funciona como identificador:
Code: [Select]
#define LOAD_ASSETS()  GD.safeload("Icons2.gd2");

Se puede colocar un índice para conseguir cargar un set de imágenes diferente para cada diseño de pantalla, como no se cargan todos los assets al mismo tiempo, la memoria del FT800 no se satura. Con este truco podemos disponer virtualmente de cualquier cantidad de archivos de iconos para usarlos en cualquier parte del proyecto. Insisto, solo se puede cargar un grupo de imagenes a la vez.

Por ejemplo podemos numerar cada asset en secuencias como:

Code: [Select]
LOAD_ASSETSa()
LOAD_ASSETSb()
LOAD_ASSETSc()


Code: [Select]
LOAD_ASSETS_0()
LOAD_ASSETS_1()
LOAD_ASSETS_2()


Code: [Select]
LOAD_ASSETS0()
LOAD_ASSETS1()
LOAD_ASSETS2()


Hay un truco que puede darnos acceso a un mayor número de archivos de imagen, consiste en ordenar dentro de cada espacio imagenes en forma vertical. Por ejemplo podríamos colocar 4 imagenes dentro del primer archivo, 4 en el segundo, etc. De esta forma podríamos disponer de hasta  14x4 = 56  celdas individuales. Esta técnica se conoce como creación de sprites. Sigo estudiándola ya que aun no la domino al 100% y los archivos me generan algunos errores de imagen, quizás haya algún aspecto de formato o de tamaño que aun no he podido estudiar a fondo. Mas adelante espero dominarlo.

                                      Sigue: uso de la pantalla táctil
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 25, 2016, 10:28 am
Uso de la pantalla táctil

El acceso a la pantalla táctil está bastante optimizado en la libreria GD2; la función para activarla es:
Code: [Select]
GD.get_inputs();

Para crear una entrada táctil se usa la siguiente instrucción:
Code: [Select]
GD.Tag(x);

Se pueden crear hasta 244 entradas táctiles (1-244), en teoría 0 también se podría usar, sin embargo en las pruebas que he hecho asignando esa entrada, la pantalla FT843 se torna inestable.

Es posible asociar entradas táctiles a objetos individuales como números, lineas de texto, gráficos primarios, imágenes, funciones con varias imágenes, incluso a cada uno de las imágenes contenidas en un asset de iconos.

Para evitar que varios objetos tengan la misma entrada táctil, se coloca la siguiente instrucción:
Code: [Select]
GD.Tag(255);
Justo después de asignar una entrada táctil a un determinado objeto.

Tomando como base el ejemplo con el arreglo de iconos creado previamente y con algunas pequeñas modificaciones, el sketch base queda así:
Code: [Select]
//22012016
#include <SPI.h>
#include <GD2.h>

#include "Icons2.h"

void setup() {
  GD.begin();
  LOAD_ASSETS0();
  MP();   //menu principal
}

void loop() {}

void MP()
{
 while(1)
 {
  GD.Clear(); 
   GD.Begin(BITMAPS);
   carga_iconos();

  GD.swap();
 }
}

void carga_iconos()
{
    GD.Vertex2ii(0, 0, 0);
    GD.Vertex2ii(0, 48, 1);
    GD.Vertex2ii(0, 96, 2);
    GD.Vertex2ii(0, 144, 3);
    GD.Vertex2ii(0, 192, 4);
    GD.Vertex2ii(60, 0, 5);
    GD.Vertex2ii(60, 48, 6);
    GD.Vertex2ii(60, 96, 7);
    GD.Vertex2ii(60, 144, 8);
    GD.Vertex2ii(60, 192, 9);
    GD.Vertex2ii(120, 0, 10);
    GD.Vertex2ii(120, 48, 11);
    GD.Vertex2ii(120, 96, 12);
    GD.Vertex2ii(120, 144, 13); 
}


Me gusta dejar aislada la función
Code: [Select]
void loop()
Tal como está estructurado el sketch, es posible conseguir la misma funcionalidad que haciéndolo sobre void loop.

Insertemos ahora un icono que usaremos como si fuera un botón de encendido y apagado; este será el objeto al que asignaremos una entrada táctil


Code: [Select]
void MP()
{
 while(1)
 {
  GD.Clear(); 
   GD.Begin(BITMAPS);
   carga_iconos();
   GD.get_inputs();   

   GD.Tag(1);  GD.Vertex2ii(300, 100, 0);  GD.Tag(255);

  GD.swap();
 }
}

Esta secuencia ya nos permitirá usar la pantalla táctil, asignando una entrada al icono 0 del arreglo de iconos. Para tener la sensación de que estamos pulsando el botón digital, podemos conseguirlo recurriendo a algunas técnicas de animación simples.

El primer paso es asignar un fondo de pantalla en color claro. Por ejemplo, podemos usar un fondo uniforme con la instrucción:
Code: [Select]
GD.ClearColorRGB(0x108000);
(http://www.mediafire.com/convkey/1ea9/3qo6zyi0923cbnozg.jpg)

También podemos establecer un degradado vertical, con el comando cmd_gradient, por ejemplo:
Code: [Select]
GD.cmd_gradient(0, 0, 0x0060c0, 0, 271, 0xc06000);
(http://www.mediafire.com/convkey/639d/5paspiu5bxfvpvrzg.jpg)

El segundo paso consiste en agregar un sombreado al botón, ésto se puede conseguir usando una máscara de color oscuro tomando tomando como base la imagen a la que queremos agregar el efecto, en este caso el botón hexagonal.

Para evitar que ajustes como la selección de un color RGB determinado, cambio de zoom, colores de relleno de gadgets; afecten todos los comandos posteriores a un cambio específico, se emplean estas dos instrucciones:
Code: [Select]
  GD.SaveContext();     

  GD.RestoreContext();

Con ellas es posible almacenar la combinación de colores y efectos previos, sin alterar el diseño  de todo el proyecto.

Code: [Select]
  GD.SaveContext();     
   GD.ColorA(50); GD.ColorRGB(0x000000); 
   GD.Vertex2ii(300, 120, 0);
  GD.RestoreContext(); 

En esta secuencia dibujamos el icono hexagonal con una degradación del color RGB=0x000000 (negro), ubicándolo 20 pixeles debajo del icono hexagonal principal. Como nos interesa conseguir un efecto de sombreado, hay que dibujarlo antes del icono en colores reales.
(http://www.mediafire.com/convkey/b6fe/7pplozzx14j0bh8zg.jpg)
Al combinar ambos gráficos obtenemos el sombreado en el icono-botón:
(http://www.mediafire.com/convkey/45b8/m783esabh8y65vyzg.jpg)

Para asegurar que la animación sea perceptible, hay que crear una bandera de control que monitoree todo el tiempo el estatus del botón. Para ello podemos crear una función que dibuje el botón en la posición 0 = apagado y 1 = encendido.

Designamos una variable o bandera, por ejemplo
Code: [Select]
int cambio_1 = 0;
Con ello indicamos que al iniciar el sketch el botón estará en la posición de apagado. Si deseamos controlar algo como un rele o bien conseguir un efecto visual con un led, por ejemplo, es conveniente que la bandera sea global.

El botón debemos dibujarlo ahora como una función con dos valores, por ejemplo
Code: [Select]
void status_1()
{
  if (cambio_1==0){GD.Vertex2ii(128, 150, 0);}
  if (cambio_1==1){GD.Vertex2ii(128, 165, 1);} 

También podemos usar un select case. La imagen que da la idea de botón encendido, corresponde a la segunda imagen del arreglo de iconos

La entrada táctil ya no estará dirigida a un solo icono, estará dirigida a las dos posiciones que tomará el botón al estar en modo encendido o en modo apagado:
Code: [Select]
   GD.Tag(1);  status_1();  GD.Tag(255);

Finalmente debemos asignar lo que se hará cuando pulsemos el botón, para ello basta con colocar un comparador usando una instrucción if, que esté ligada al valor de la entrada táctil 1

Code: [Select]
if (GD.inputs.tag==1){
          delay(155);
          cambio_1=cambio_1+1;
          if (cambio_1>=2){cambio_1=0;}
        }

No soy partidario de usar delays, sin embargo en las entradas táctiles resulta muy útil colocar un pequeño lapso de espera de entre 145 y 200 ms, esto permite que la pantalla táctil no se sature de datos y dé la impresión de que la estamos presionando constantemente, haciéndonos suponer que no funciona correctamente.

Este es el núcleo principal del sketch:

Code: [Select]
void MP()
{
 while(1)
 {
//  GD.ClearColorRGB(0x108000);   
  GD.Clear(); 
  GD.cmd_gradient(0, 0, 0x0060c0, 0, 271, 0xc06000);
   GD.Begin(BITMAPS);
   carga_iconos();
   GD.get_inputs();   

  GD.SaveContext();     
   GD.ColorA(50); GD.ColorRGB(0x000000); 
   GD.Vertex2ii(300, 120, 0);
  GD.RestoreContext(); 

   GD.Tag(1);  status_1();  GD.Tag(255);
   
    if (GD.inputs.tag==1){
          delay(195);
          cambio_1=cambio_1+1;
          if (cambio_1>=2){cambio_1=0;}
        }         
  GD.swap();
 }
}

void status_1()
{
  if (cambio_1==0){GD.Vertex2ii(300, 100, 0);}
  if (cambio_1==1){GD.Vertex2ii(300, 120, 1);} 
}

Este es el resultado en el TFT (https://www.youtube.com/watch?v=ZY52WTJ9wnM)

                                Sigue: creación de un menu principal y de submenus
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 07, 2016, 08:14 am
Base para armar un árbol de menus

Un conjunto de menus puede simplificarse a un grupo de funciones que pueden intercambiarse mediante una entrada táctil. En este esquema podemos disponer de una pantalla principal o menu principal. el número de menus adicionales dependerá de lo que deseemos ver en pantalla, podemos disponer de menus secundarios o sub-menus en los que podríamos ver en tiempo real los datos adquiridos por sensores, un gráfico de comportamiento, una gráfica de calibración, un visor de imágenes, un grupo de opciones para ajuste de parámetros, etc.

Hasta donde he podido experimentar pueden usarse tantos menus como permita el espacio de programación de la placa arduino que estemos usando.

La estructura de cada función o parte del menu debe tener estos elementos:

Code: [Select]
Identificador de menu
Instrucciones que se ejecutan una vez
Instrucciones que cambian con el tiempo
Instrucciones de entrada táctil


Esta estructura es independiente de la librería del controlador táctil, solo depende del tipo de controlador de pantalla.

En TFT´s con pantalla táctil comunes como las que tienen el controlador ILI9341, SSD1289 o HX8357 por ejemplo, que usan la librería Utouch, las instrucciones que se ejecutan una sola vez (textos o fondos de pantalla), deben colocarse fuera del bucle principal, ya que pueden producir parpadeos o comportamientos intermitentes en la pantalla.

En el caso del controlador FT8XX, esas instrucciones deben ubicarse dentro del bucle principal, ya que de lo contrario pueden producirse errores de coprocesador o "pantallazos azules".

Un menu simple lo podemos conseguir tomando como punto de partida el ejemplo del botón simple que se construyó previamente, basta con adicionar un segundo tag y modificando la posición vertical, para colocarlo por debajo del otro botón.


Code: [Select]
GD.SaveContext();    
   GD.ColorA(50); GD.ColorRGB(0x000000);  
   GD.Vertex2ii(300, 120, 0);
   GD.Vertex2ii(300, 180, 0);  
  GD.RestoreContext();  

   GD.Tag(1);  GD.Vertex2ii(300, 100, 0);  GD.Tag(255);    //botón superior
  
    if (GD.inputs.tag==1){
          delay(195);
          menu_1();
        }

   GD.Tag(2);  GD.Vertex2ii(300, 160, 0);  GD.Tag(255);    //botón inferior
  
    if (GD.inputs.tag==2){
          delay(195);
          menu_2();
        }


(http://www.mediafire.com/convkey/dcd8/rrvpd0hqj1jj26xzg.jpg)

Omití el cambio de estado en cada botón, ya que al tocarlo, el cambio al menu siguiente es inmediato.

El primer menu lo he llamado menu_1, el segundo lo he designado como menu_2. El menu principal lo he llamado MP, de esta forma podemos ubicar fácilmente cada función o elemento del menu, cuando estemos depurando el programa.

(http://www.mediafire.com/convkey/983c/r947p5n9lyq7jvfzg.jpg)

El menu_1 solo dispone de un botón que regresa al menu principal, el menu_2, tiene dos botones: retorno a menu principal y acceso al menu_3, como fondo muestra 5 iconos en posiciones aleatorias.

(http://www.mediafire.com/convkey/0d4b/huu4gxdaonjw89dzg.jpg)

En el menu_3 coloqué un analizador de espectro en forma de barras segmentadas, dispone de un botón de retorno al menu previo (menu_2) y otro para ir al menu principal. Como fondo tiene un icono en posiciones aleatorias. Este menu solo es accesible desde el menu_2.

(http://www.mediafire.com/convkey/8c39/8dnhfu0wud140vdzg.jpg)

Video: menu simple (https://www.youtube.com/watch?v=Vpgr63d8VY4)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 10, 2016, 12:22 am
En lo que llega el shield sobre el que instalaré todos los componentes del controlador, he estado experimentando algunas variantes en las que podría usar el FT843 o la pantalla ILI9341 que usaré como pantalla secundaria.

FT800 en arduino MEGA
La versión mas reciente de la librería para el gameduino 2 funciona sin problemas en el arduino Due, también funciona en el MEGA, en el Teensy 3.2 y me parece que en el Rasberri Pi.

Por consiguiente el FT843 podría funcionar en esas placas mediante la librería GD2, con los ajustes adecuados para que los parámetros de inicialización correspondan a los del gameduino 2.

El diseño del gameduino 2 corresponde a un shield para arduino UNO. La librería tiene algunos ajustes para funcionar directamente sobre el arduino Due, para que funcione en el MEGA hay que hacer algunos ajustes en el hardware, se deben unir los pines 51 a 11 (MOSI), 50 a 12 (MISO) y 52 a 13 (SCK). Hay dos posibilidades para conseguirlo: unirlos mediante cableado o bien construir un shield, intercalando un dip switch-3, con la finalidad de desconectar las uniones cuando no se use la pantalla FT800.

(http://www.mediafire.com/convkey/18f5/wl1y73ud56gufnqzg.jpg)

(http://www.mediafire.com/convkey/4faf/d322bxaccc6dqpbzg.jpg)

Dos pantallas ILI9341 en Teensy 3.2
Aparentemente el Due, el Mega o el Uno, pueden manejar dos pantallas ILI9341 al mismo tiempo, mostrando información distinta en cada una de ellas. En las pruebas que hice experimenté en el arduino UNO, pero estaba el problema de la memoria, tenía muy poca disponible y no me permitió avanzar. En el MEGA resultó muy lento el control de las dos pantallas, las entradas táctiles no funcionan correctamente

El Due lo quiero para controlar el gameduino 2, si instalo una segunda pantalla como la ILI9341 de 2.4", el GD2 deja de funcionar.

Construí un shield para experimentar con el teensy 3.2 que llegó hace un par de semanas. En una de las caras, el shield permite conectar directamente el gameduino 2; en la otra cara, permite instalar una pantalla ILI9341 de 2.2", 2.4" o de 2.8".

(http://www.mediafire.com/convkey/b989/a0btnafa5ybhoszzg.jpg)

(http://www.mediafire.com/convkey/5b1f/s0b9f5r84nu3tx8zg.jpg)

El árbol de conexionado que usé es el siguiente:
Code: [Select]
ILI9341            Teensy 3.2
VCC                   VIN
GND                   GND
CS                     10
RESET                3.3V
D/C                     9
SDI (MOSI)             11
SCK                    13
LED                   VIN    (resistencia de 100 ohms)
SD0(MISO)              12
T_CLK                   6
T_CS                    5
T_DIN                   4
T_DO                    3
T_IRQ                   2

La librería para usar el panel táctil es la Utouch.

El problema que encontré es que el lector SD de la pantalla ILI9341 no funciona al usarlo en el teensy. Aparentemente hay que modificar el circuito puenteando las resistencias smd que se ubican bajo la carcasa del lector SD, hice algunas pruebas y no conseguí hacerlo funcionar.

Decidí instalar uno de los lectores micro SD que conseguí para el FT843, funcionan de forma nativa a 3.3V. Conecté el lector al bus SPI, tanto la librería SD como la SDfat responden.

(http://www.mediafire.com/convkey/85a2/7jxn9otl7t6qu6jzg.jpg)

Hasta aquí todo parece funcionar con el shield, decidí complicar las cosas y conecté la segunda pantalla ILI9341. Si se conecta en forma paralela pin a pin respecto a la primer pantalla, se consigue que ambas pantallas muestren la misma información.

Si se define una segunda instancia de configuración y se conecta el pin CS a otro pin digital (20 o 21), se consigue controlar cada pantalla de forma independiente.

(http://www.mediafire.com/convkey/7f73/b7nzdrv291a77d5zg.jpg)

Con algunas modificaciones en la rutina de lectura de archivos bmp, es posible enviar imágenes diferentes en cada pantalla
(http://www.mediafire.com/convkey/6686/fcis14uf2r12f51zg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 18, 2016, 08:57 am
Conseguí una pantalla ILI9341 de 3.2" que se conecta a 16 bits. Se requieren 33 hilos para conectar el lector SD (6), el panel táctil (5) y el TFT (22). Era la pantalla que quería desde que migré de los LCD´s gráficos a TFT´s, pero por falta de presupuesto no la había podido conseguir.

Hace unos días conseguí un par de protoboards para mega que ajustan muy bien en el due, por lo que decidí armar una placa de pruebas para la pantalla, logré insertar en la libreria UTFT un iniciador basado en el ILI9341 5SPI. También funciona con el constructor del ILI9327, pero hay que modificar la resolución en el archivo UTFT.ccp.

(http://www.mediafire.com/convkey/dd40/e08etrgyr56roh5zg.jpg)
El shield permite conectar directamente la pantalla en un zócalo de 34 pines, o bien se puede construir una extensión para conseguir una mayor flexibilidad al usar la pantalla en un proyecto. Adicioné un zócalo de 6 pines en el que se puede instalar un lector microSD.

Acá está la base de expansión del FT843 hecha con la otra protoboard:
(http://www.mediafire.com/convkey/bb4b/6621qjh9vywnj0bzg.jpg)

Ya puedo concentrarme en otros aspectos del controlador como el diseño de los registros de avance de los proyectos del trabajo:
(http://www.mediafire.com/convkey/4a76/c36oa7txf9vb96szg.jpg)

Por fin puedo dedicarle tiempo al manejo de imágenes con la librería GD2, razón por la que tuve que pausar el diseño del controlador.
Video: desplazamiento de iconos (https://www.youtube.com/watch?v=45auLwBeFCs)
Title: Re: Algunos consejos para usar TFT´s
Post by: Nomada on Feb 20, 2016, 09:18 pm
ehh excelente post
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 23, 2016, 02:18 am
Gracias, espero que a alguien por allá fuera le sirva de algo.

Dibujo de indicadores analógicos en el FT843

Estoy instalando los sensores de temperatura NTC en el proto-shield. En lo que consigo algunas resistencias SMD en el rango de 6 a 8 K, le dediqué un tiempo al diseño de la función que permitirá dibujar gauges, diales o indicadores de aguja.

Hasta ayer los intentos me habían llevado al limite de la horizontal, acotado por el rango de ángulos entre 0 y 180. El enfoque era convertir el valor de la variable, el valor máximo de la escala del dial y el ángulo máximo. En ese concepto el ángulo inicial siempre es 0. Como los indicadores de aguja tienen su valor máximo hacia el extremo derecho del dial, me topé con el limite de 180 grados.

Code: [Select]
Tetha = (180 * Variable/ValorMaximo);

Si recordamos algunos conceptos matemáticos del circulo unitario, bajo el cuadrante I, el cuadrante que sigue es el cuadrante IV, allí el ángulo que seguiría de 180 (si lo vemos al revés), es el ángulo 359, no el 181.

Por esta razón al dibujar en el TFT obtenía agujas o marcas fuera de lugar donde esperaría que estuvieran, encima no hay que olvidar que las coordenadas del eje y están invertidas. Decidí dejar los diales en el rango de 0 a 180 grados.

Estoy poco familiarizado con las funciones heredadas de C que tiene el IDE de arduino y de poco a poco he aprendido a usar. Toca el turno a la función map().

Al usar esa función para calcular el ángulo equivalente a una lectura, se puede conseguir superar la barrera de la horizontal y curiosamente, la orientación invertida del eje y. Por ejemplo, la instrucción:
Code: [Select]
Tetha = map(Variable, 0, ValorMaximo, -30, 210);
Permite dibujar un dial horizontal que inicia en el ángulo -20 (corresponde a 200 en coordenadas normales) y termina en el ángulo 210 (340 en coordenadas normales)

Llevada al extremo, la función permite dibujar diales verticales o de rango corto como el que tienen algunos indicadores de presión. Este es un ejemplo con tres indicadores:
(http://www.mediafire.com/convkey/ad85/guckducuai88pygzg.jpg)

Video: indicadores analogicos (https://www.youtube.com/watch?v=FOhaWL84bKU&feature=youtu.be)
Title: Re: Algunos consejos para usar TFT´s
Post by: GDCR on Feb 27, 2016, 10:45 pm
Hola, estoy trabajando con una pantalla LCD Touch TFT_320QVT, ella trae una memoria SD para cargar las imágenes en .RAW y montarlas asi en la LCD, hasta ahí todo normal, el problema es que quiero guardar datos de la lectura de sensores en la misma SD pero no lo he logrado, en la libreria TinyFAT dice que se pueden leer y escribir datos en ella pero he probado con los ejemplos y ninguno me funciona, crea los archivos pero no escribe nada en ellos, los deja vacios. Estoy pensando en utilizar el modulo aparte de memorias SD solo para guardar los datos y dejar la SD de la pantalla solo para montar las imagenes, es lo unico que se me ocurre. Me seria de gran ayuda que si sabes como guardar datos en la misma memoria me colabores, Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 28, 2016, 10:46 pm
Hola, estoy trabajando con una pantalla LCD Touch TFT_320QVT, ella trae una memoria SD para cargar las imágenes en .RAW y montarlas asi en la LCD, hasta ahí todo normal, el problema es que quiero guardar datos de la lectura de sensores en la misma SD pero no lo he logrado, en la libreria TinyFAT dice que se pueden leer y escribir datos en ella pero he probado con los ejemplos y ninguno me funciona, crea los archivos pero no escribe nada en ellos, los deja vacios. Estoy pensando en utilizar el modulo aparte de memorias SD solo para guardar los datos y dejar la SD de la pantalla solo para montar las imagenes, es lo unico que se me ocurre. Me seria de gran ayuda que si sabes como guardar datos en la misma memoria me colabores, Gracias
Para la gestión de datos e imagenes RAW, debes definir dos instancias de acceso a la libreria:

Code: [Select]
UTFT_tinyFAT myFilesB(&myGLCD); 
SdFat sd;      //Carga de imagenes RAW 

SdFat sd1;     //Gestión de datos
SdFile myFile;


Dentro del setup te sugiero que uses estas lineas, para activar cada una de las instancias de acceso al lector SD:
Code: [Select]
  if (!sd.begin(chipSelect, SPI_FULL_SPEED)) {sd.begin(chipSelect, SPI_HALF_SPEED);}
 if (!sd1.begin(chipSelect, SPI_FULL_SPEED)) {sd1.begin(chipSelect, SPI_HALF_SPEED);}


Separa por funciones los procesos de gestión de datos, por ejemplo:

Code: [Select]
1 Crear archivo/guardar datos
2 Leer datos
3 Eliminar archivo
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Mar 07, 2016, 07:09 pm
Indicadores analógicos: uso de CPU y uso de RAM en el TFT

He estado recopilando los programas individuales para hacer funcionar cada uno de los componentes del controlador. En este proceso, retomé un aspecto que me hubiese gustado poder desarrollar personalmente, pero por cuestiones de tiempo y de poco dominio de C, Phyton o similares, no he podido profundizar: la comunicación a por el puerto serie de arduino con la PC. Me refiero a enviar datos de la PC al arduino como por ejemplo, temperaturas, uso del CPU o uso de la RAM.

Hace un tiempo encontré un proyecto con indicadores analógicos que me pareció bastante completo:

http://www.lungstruck.com/projects/pc-meter/ (http://www.lungstruck.com/projects/pc-meter/)

Video: indicadores de uso de CPU/RAM analógicos (https://www.youtube.com/watch?v=L3PxN10NTsk)

En aquel momento no pude replicar el proyecto ya que no alcanzaba a entender como es que funcionaba el software de apoyo y mucho menos las funciones clave que permiten conseguir los dos valores: %CPU y %RAM.

Nuevamente revisé el código y por fin pude extraer los elementos que permiten leer los valores de uso del CPU y uso de la RAM. Estas son las funciones núcleo del programa:

Code: [Select]
//Inicia CPU array/total con ceros
void initCpuValues()
{
  for (int counter = 0; counter < CPU_READINGS; counter++)
    cpuReadings[counter] = 0;
    cpuTotal = 0;
}


void LeeCPURAM()
{
  while (Serial.available() > 0)
   {
   Serial.readBytesUntil('\r', buffer, 5);
   //Thought this might be needed based on example I studied, seems okay without
   //buffer[4] = '\0';
   switch (buffer[0])
   {
    case 'C':
     cpuTotal = cpuTotal - cpuReadings[cpuIndex];
     cpuReadings[cpuIndex] = min(atoi(&buffer[1]), 100);
     cpuTotal = cpuTotal + cpuReadings[cpuIndex];
 // Uso de CPU
     UsoCorei73770 = cpuTotal / CPU_READINGS;  //desmarcar luego de las pruebas
    
     //Advance index
     cpuIndex = cpuIndex + 1;
     if (cpuIndex >= CPU_READINGS)
       cpuIndex = 0;
     break;

    case 'M':
//Uso de RAM
    UsoRAM = min(atoi(&buffer[1]), 100);

     break;
     }
  
   //Reset for next measurement
   perc = 0;
   memset(buffer, ' ', 5);
   //Update last serial received
   lastSerialRecd = millis();
  }
}



Estas variables deben ser globales:

Code: [Select]
//Constantes para PC Meter
const long SERIAL_TIMEOUT = 0;  //How long to wait until serial "times out"
const int CPU_READINGS = 3;        //Number of readings to avg. for CPU load%

//Variables
unsigned long lastSerialRecd = 0;     //Time last serial read
float cpuReadings[CPU_READINGS];        //array of cpu load% readings
float cpuTotal = 0;                     //CPU load running total
int cpuIndex = 0;                     //current position in array for cpu load%

  char buffer[5];                //buffer
  int perc = 0;                  //reading
  
  float  UsoCorei73770;  //tengo un core i7 3370, de allí el nombre de la variable
  float UsoRAM;


Estas lineas van dentro del setup:

Code: [Select]
 Serial.begin(9600);
  initCpuValues();
  lastSerialRecd = millis();  //Give meter some time to start receiving data


El programa que permite obtener los datos y enviarlos por usb hasta el arduino se llama PC Meter, lo creó el autor del proyecto en Visual C#. Tiene algunos inconvenientes, que no creo se hayan resuelto todavía:

- Bloquea la carga de sketchs al arduino, desconectando la captura todo funciona normalmente
- Impide la hibernación de windows, cerrándolo se evita el problema
- Impide el reinicio de la PC, cerrándolo se acaba el problema

Hay algunas otras complicaciones con los medidores analógicos usados en el proyecto original, pero que no se tendrán en el TFT, ya que acá no hay una conversión digital a voltaje, todo es digital.

Tomé como base el sketch de indicadores analógicos, y adicioné algunos textos.

Video: uso CPU y RAM (https://www.youtube.com/watch?v=DjDtmu0PEkQ)

La velocidad de actualización me parece algo lenta, y le falta algo de fluidez, parece ser que dentro del programa PC Meter hay algunos delays que inciden en la velocidad de refresco, sin embargo ya tengo acceso a los datos comportamiento de la PC.

(http://www.mediafire.com/convkey/b6ea/9ujeqx44cmeyq9pzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on May 30, 2016, 08:21 am
He estado tratando de comprender mejor el funcionamiento del FT800. Se agradece la tasa de refresco de la pantalla y eso reduce mucho del esfuerzo de programación, pero a veces pueden diseñarse pantallas algo confusas, cargadas de "velocidad", que dificultan su uso dentro de un sketch.

Se pueden usar atajos como delays, pero soy enemigo de ese recurso, desde que aprendí a usar el ejemplo Blink without Delay. Aunque arduino no está diseñado para ejecutar multifunciones, es posible combinar varios contadores basados en millis() que nos permiten saltar de alguna forma esa barrera.

Optimización del movimiento de las agujas de los indicadores analógicos

Cuando diseñé el lector analógico para monitorear el uso de CPU/RAM de la PC, me dí cuenta de que al usar valores aleatorios en los indicadores, se hace presente la abrumadora velocidad de la pantalla. Es poco apreciable en rangos de entre 4 hasta 10 unidades, sin embargo en rangos de 15 o mas unidades entre lecturas, se observan saltos en las agujas.

Para conseguir que el desplazamiento de la aguja tenga una respuesta mas definida, es necesario incluir una componente que proporcione una velocidad gradual de desplazamiento, dando la impresión de que la agua o (una lectura) tiene la inercia que confiere un resorte o una respuesta gradual. La secuencia de análisis tiene estos pasos:

1) Adquisición de la primer lectura para tomarla como base.
Code: [Select]
void LecturaSensor1(){
   T1 = random(100);
}

T1a = T1, T1g = T1

2) Se asigna un intervalo de lectura: 1 s (1000 ms), 2 seg (2000 ms), etc. Controlado por millis(), en lugar de delay()
3) Se toma una segunda lectura del sensor.
4) Se determina si se trata de un incremento (velocidad positiva), decremento (velocidad negativa), o que no hay cambios en la lectura (velocidad= 0)

Code: [Select]
  unsigned long currentMillis1 = millis();       
  if(currentMillis1 - previousMillis1 > interval1)
  {
    previousMillis1 = currentMillis1;       

    LecturaSensor1();
    T1b = T1;
    DT1 = T1b - T1a;
    if (DT1>0){DT1g=1;}else{if (DT1<0){DT1g=-1;}else{DT1g=0;}}
  }


Como resultado podemos conseguir el signo de valor del cambio: +(si hay un incremento), -(si hay una reducción) o 0 (si no hay cambios)

5) Se aplica la velocidad al valor base. Lo forma mas simple es aumentar gradualmente el valor de la lectura base, hasta igualar el valor de la segunda lectura.
Code: [Select]
   if (T1g==T1b){T1g=T1b;}else{T1g = T1g + DT1g;}

6) Gráficar el cambio gradual de la lectura base. Este paso es el que nos permite mostrar los cambios de la lectura de un sensor de forma atenuada, tal como lo hace un velocímetro o el mercurio dentro de un termómetro.

Vídeo: indicadores analógicos optimizados (https://www.youtube.com/watch?v=kTewnMdWJrg)

Al llegar al valor objetivo, (es decir la segunda lectura, T1b), la variable (T1g) final, se convierte en el nuevo valor base (T1a), repitiendo el ciclo de tratamiento de la lectura. El menor intervalo entre la adquisición de lecturas, lo recomiendo establecer entre 500 y 700 ms.

PD: no podemos escaparnos de los códigos complejos, llega un momento en el que hay que codificar acciones tan simples como evaluar una variable, cuyo valor puede tomar tres o mas caminos y eso nos lleva a escribir lineas y lineas. Trataré de depurar el código para hacerlo mas comprensible.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 04, 2016, 09:21 pm
Recientemente llegaron los conversores de Riverdi para cable plano a zócalo de pines. Este tipo de adaptador permite conectar de forma directa las pantallas de la serie FT80x y FT81x. Mi idea es poder construir un shield que me permita conectar cualquier tipo de pantalla de Riverdi, basada en los chips de FTDI, sin tener que lidiar con rollos de cables de prototipado.

Espero en los próximos días armar el rompecabezas para por fin conectar la pantalla capacitiva de 4.3" FT801, que tengo de pisapapeles desde hace meses. Ya les compartiré los avances. Me temo que tendré que modificar una vez mas la librería GD2, esperemos que de forma nativa funcione correctamente.

PD: como he dicho siempre, no soy vendedor ni distribuidor, simplemente me di a la tarea de filtrar las especificaciones que ofrecen los constructores de este tipo de pantallas, y me he inclinado por ese proveedor. Tampoco voy a construir algo para vender, simplemente quiero contar con buenas piezas para el hobbie.

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 19, 2016, 09:16 pm
El principio de funcionamiento de la pantalla FT801 está considerado dentro de las librerias para el gameduino 2: (la gameduino2 y la GD2, que corresponde a la versión multifuncional FT80x/FT81x)

Las lineas de conexión para cualquier pantalla FT80x a un arduino Due son:

Code: [Select]
FT80x    Due
GND      GND
VCC      3V3
MOSI     MOSI
MISO     MISO
SCK      SCK
CS       pin digital disponible


Las lineas extra que tiene cualquier pantalla FT80x: INT y PD, no se usan en las librerias para gameduino 2.

Adicionalmente, la mayoría de pantallas FT80x no tienen un lector SD, y pocas tienen instalado el amplificador en la salida de audio.

Para adicionar un lector SD, se puede usar un lector microSD. En los experimentos previos para anexar un lector, me di cuenta que debe estar diseñado para 3.3V, y no debe tener instalado un regulador de voltaje 5V/3.3V. Para minimizar las fallas, cada linea debe unirse a las lineas MOSI/MISO/SCK de la  pantalla

La memoria micro SD recomiendo que sea de 4Gb, clase 4, preferentemente kingston, formateada en FAT32.

¿Por qué usar las librerias del gameduino 2, en lugar de las diseñadas por FTDI?. Es bastante simple.

Veamos el ejemplo hello world que viene en la libreria FTDI para el FT843


Code: [Select]
/* This application demonstrates the usage of FT800 library on FT_ADAM_4DLCD_FT843 platform */

/* Arduino standard includes */
#include "SPI.h"
#include "Wire.h"

/* Platform specific includes */
#include "FT_ADAM_4DLCD_FT843.h"

/* Global object for FT800 Implementation */
FT800IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

/* Api to bootup ft800, verify FT800 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure()
{
uint32_t chipid = 0;
FTImpl.Init(FT_DISPLAY_WQVGA_480x272);//configure the display to the WQVGA

delay(20);//for safer side
chipid = FTImpl.Read32(FT_ROM_CHIPID);

/* Identify the chip */
if(FT800_CHIPID != chipid)
{
Serial.print("Error in chip id read ");
Serial.println(chipid,HEX);
return 1;
}

/* Set the Display & audio pins */
FTImpl.SetDisplayEnablePin(FT_DISPENABLE_PIN);
    FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN);
FTImpl.DisplayOn();
FTImpl.AudioOn(); 
return 0;
}

/* API to display Hello World string on the screen */
void HelloWorld()
{
/* Change the below string for experimentation */
const char Display_string[12] = "Hello World";

/* Display list to display "Hello World" at the centre of display area */
FTImpl.DLStart();//start the display list. Note DLStart and DLEnd are helper apis, Cmd_DLStart() and Display() can also be utilized.
FTImpl.ColorRGB(0xFF,0xFF,0xFF);//set the color of the string to while color
FTImpl.Cmd_Text(FT_DISPLAYWIDTH/2, FT_DISPLAYHEIGHT/2, 29, FT_OPT_CENTER, Display_string);//display "Hello World at the center of the screen using inbuilt font handle 29 "
FTImpl.DLEnd();//end the display list
FTImpl.Finish();//render the display list and wait for the completion of the DL
}

/* bootup the module and display "Hello World" on screen */
void setup()
{
/* Initialize serial print related functionality */
Serial.begin(9600);

/* Set the Display Enable pin*/   
Serial.println("--Start Application--");
if(BootupConfigure())
{
//error case - do not do any thing
}
  else
{
HelloWorld();
}
Serial.println("--End Application--");
}

/* Nothing in loop api */
void loop()
{
}

Sketch uses 26,800 bytes (5%) of program storage space. Maximum is 524,288 bytes.

Al familiarizarme con la libreria FTDI, me di cuenta que se puede prescindir de muchas lineas de código, pero otras deben usarse todo el tiempo, ya que se comunican directamente con el micro FT80x, y al no usarlas se producen errores de procesamiento (pantallazos azules XD).

Este es el ejemplo hello world de la libreria GD2:

Code: [Select]
#include <SPI.h>
#include <GD2.h>

void setup(){ Serial.begin(1000000); // JCB
  GD.begin(0);}

void loop(){GD.ClearColorRGB(0x103000);
  GD.Clear();
  GD.cmd_text(GD.w / 2, GD.h / 2, 31, OPT_CENTER, "Hello world");
  GD.swap();}

Sketch uses 13,664 bytes (2%) of program storage space. Maximum is 524,288 bytes.

Creo que las diferencias son mas que evidentes.

No es solo conectar la nueva pantalla, hay que hacer algunos ajustes en la libreria GD2 para que las pantallas FT80x se comporten como lo hace la pantalla del gameduino 2.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 20, 2016, 09:53 pm
Librerias para gameduino 2

Gameduino 2 (y FT80x):
http://excamera.com/files/Gameduino2.zip (http://excamera.com/files/Gameduino2.zip)

Libreria en desarrollo para gameduino 2, con soporte para FT8xx: https://github.com/jamesbowman/gd2-lib (https://github.com/jamesbowman/gd2-lib)

Ajuste de la libreria GD2

Me centraré en los pasos para modificar la libreria GD2 y dejarla a punto para cualquier tipo de pantalla FT80x. Con el FT813 tendré que invertir mucho mas tiempo...

Luego de descargar el zip, hay que limpiar un poco el directorio, ya que prácticamente "estamos entrando a una parte del taller de James"
(http://www.mediafire.com/convkey/4053/0w75mjl937184cfzg.jpg)

Ubicamos la libreria en la carpeta correspondiente para que se active en el IDE de arduino:
(http://www.mediafire.com/convkey/8d1e/doc3wuq4045mqfxzg.jpg)

Estas son las lineas que se encuentran en el archivo GD2.ccp original

Code: [Select]
#define SD_PIN        9    // pin used for the microSD enable signal

#define BOARD_FTDI_80x    0
#define BOARD_GAMEDUINO23 1
#define BOARD_EVITA_0     2

#define BOARD         BOARD_GAMEDUINO23 // board, from above
#define STORAGE       1                 // Want SD storage?
#define CALIBRATION   1                 // Want touchscreen?

// FTDI boards do not have storage
#if (BOARD == BOARD_FTDI_80x)
#undef STORAGE
#define STORAGE 0
#endif


Ésta es la versión personalizada para ajustarse al shield de Riverdi para arduino (pantallas FT80x y FT81x), con soporte para lector micro SD externo

Code: [Select]
#define SD_PIN               5   //5--->SD-Riverdi shield,  9--->para gameduino 2

#define BOARD_FTDI_80x       0
#define BOARD_GAMEDUINO23    1
#define PROTO                0   //0-->FT843, FT80x; 1--> MEGA, UNO, gameduino 2
#define BOARD_EVITA_0        2

#define BOARD                0         // board, from above
#define STORAGE              1   // Want SD storage?
#define CALIBRATION          1   // Want touchscreen?

// FTDI boards do not have storage
#if (BOARD == BOARD_FTDI_80x)
#undef STORAGE
#define STORAGE              1
#endif


La instrucción PROTO en GD2

PROTO, definida en la linea siguiente:
Code: [Select]
#define PROTO                0

Permite controlar la disposición de la tabla de colores, orientación de pixeles y orientación del panel táctil de las pantallas FT80x. El gameduino 2 tiene una disposición "invertida", respecto al diseño original de FTDI, la razón posiblemente se deba al ángulo de visión de la pantalla del shield gameduino 2.

En la libreria nueva (GD2), esa linea ha sido suprimida, es importante rescatarla, ya que resulta mucho mas fácil manipular el cableado, con la orientación que tiene el gameduino 2, que con la disposición que tiene de fábrica el FT80x.

En el archivo GD2.ccp original, las lineas en las que debemos insertar la instrucción están dispuestas de esta forma:

Code: [Select]
#if (BOARD == BOARD_FTDI_80x)
  GDTR.wr(REG_PCLK_POL, 1);
  GDTR.wr(REG_PCLK, 5);
#endif
  GDTR.wr(REG_PWM_DUTY, 0);
  GDTR.wr(REG_GPIO_DIR, 0x83);
  GDTR.wr(REG_GPIO, GDTR.rd(REG_GPIO) | 0x80);

#if (BOARD == BOARD_GAMEDUINO23)
  ConfigRam cr;
  byte v8[128] = {0};
  cr.read(v8);
  if ((v8[1] == 0xff) && (v8[2] == 0x01)) {
    options &= ~(GD_TRIM | GD_CALIBRATE);
    if (v8[3] & 2) {
      GDTR.__end();
      GDTR.hostcmd(0x44); // switch to external crystal
      GDTR.resume();
    }
    copyram(v8 + 4, 124);
    finish();
  } else {
    GDTR.wr(REG_PCLK_POL, 1);
    GDTR.wr(REG_PCLK, 5);
    GDTR.wr(REG_ROTATE, 1);
    GDTR.wr(REG_SWIZZLE, 3);
  }
#endif


La secuencia de instrucciones que permite modificar la rotación de colores, panel táctil y pixeles en las pantallas FT80x queda así:

Code: [Select]
#if (BOARD == BOARD_FTDI_80x)
  GDTR.wr(REG_PCLK_POL, 1);
  GDTR.wr(REG_PCLK, 5);

// Avoid inverted colours on alternative-FT800 boards
#if PROTO == 1
  GDTR.wr(REG_ROTATE, 1);
  GDTR.wr(REG_SWIZZLE, 3);
#endif
    GDTR.wr(REG_ROTATE, 1);   
// Avoid inverted colours on alternative-FT800 boards

#endif
  GDTR.wr(REG_PWM_DUTY, 0);
  GDTR.wr(REG_GPIO_DIR, 0x83);
  GDTR.wr(REG_GPIO, GDTR.rd(REG_GPIO) | 0x80);

#if (BOARD == BOARD_GAMEDUINO23)
  ConfigRam cr;
  byte v8[128] = {0};
  cr.read(v8);
  if ((v8[1] == 0xff) && (v8[2] == 0x01)) {
    options &= ~(GD_TRIM | GD_CALIBRATE);
    if (v8[3] & 2) {
      GDTR.__end();
      GDTR.hostcmd(0x44); // switch to external crystal
      GDTR.resume();
    }
    copyram(v8 + 4, 124);
    finish();
  } else {
    GDTR.wr(REG_PCLK_POL, 1);
    GDTR.wr(REG_PCLK, 5);

// Avoid inverted colours on alternative-FT800 boards
#if PROTO == 1
  GDTR.wr(REG_ROTATE, 1);
  GDTR.wr(REG_SWIZZLE, 3);
#endif
    GDTR.wr(REG_ROTATE, 1);   
// Avoid inverted colours on alternative-FT800 boards
  }
#endif


Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 20, 2016, 10:06 pm
Resta modificar el archivo wiring.h, para ajustar el cableado a la disposición del shield-arduino de Riverdi.

Primeras lineas del archivo wiring.h original:

Code: [Select]
#ifndef CS
#define CS 8
#endif

class GDTransport {
private:
  byte model;
public:
  void ios() {
    pinMode(CS, OUTPUT);
    digitalWrite(CS, HIGH);
    pinMode(9, OUTPUT);
    digitalWrite(9, HIGH);


Archivo wiring.h ajustado:

Code: [Select]
#ifndef CS
#define CS 10
#endif

class GDTransport {
private:
  byte model;
public:
  void ios() {
    pinMode(CS, OUTPUT);
    digitalWrite(CS, HIGH);
    pinMode(5, OUTPUT);
    digitalWrite(5, HIGH);


Adjunto los archivos modificados. Funcionan para pantallas FT80x, gameduino2 en placas arduino como el Due, UNO, MEGA(hay que soldar algunas lineas externas entre MOSI, MISO y SCK a los pines correspondientes 11, 12 y 13). También funciona para el teensy 3.2.

Hardware de pruebas:

- Arduino Due
- Shield casero para el break out de 20 pines de Riverdi (https://riverdi.com/product/break-out-board-20/)
- FT801 con panel táctil capacitivo (https://riverdi.com/product/rvt43ulfnwc0x/)
- Lector micro SD para soporte del FT801 (http://www.chinalctech.com/index.php?_m=mod_product&_a=view&p_id=646)
- MicroSD de 4Gb, kingston, clase 4 (formateada en fat32) para usar en conjunto con la libreria GD2
- Lector micro SD para almacenamiento general (un módulo catalex, que al día de hoy no dónde se fabrica!!!)
- MicroSD de 10Gb, kingston, clase 10 (formateada en fat32) para el módulo catalex
- OLED de 96x64 (a colores)

(http://www.mediafire.com/convkey/cb3b/shdll54q5rmgnl5zg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 21, 2016, 10:42 am
El principio de funcionamiento de la pantalla FT801 está considerado dentro de las librerias para el gameduino 2: (la gameduino2 y la GD2, que corresponde a la versión multifuncional FT80x/FT81x)

Las lineas de conexión para cualquier pantalla FT80x a un arduino Due son:

Code: [Select]
FT80x    Due
GND      GND
VCC      3V3
MOSI     MOSI
MISO     MISO
SCK      SCK
CS       pin digital disponible



Este es el ejemplo hello world de la libreria GD2:

Code: [Select]
#include <SPI.h>
#include <GD2.h>

void setup(){ Serial.begin(1000000); // JCB
  GD.begin(0);}

void loop(){GD.ClearColorRGB(0x103000);
  GD.Clear();
  GD.cmd_text(GD.w / 2, GD.h / 2, 31, OPT_CENTER, "Hello world");
  GD.swap();}

Sketch uses 13,664 bytes (2%) of program storage space. Maximum is 524,288 bytes.

Creo que las diferencias son mas que evidentes.

No es solo conectar la nueva pantalla, hay que hacer algunos ajustes en la libreria GD2 para que las pantallas FT80x se comporten como lo hace la pantalla del gameduino 2.
El principio de funcionamiento de la pantalla FT801 está considerado dentro de las librerias para el gameduino 2: (la gameduino2 y la GD2, que corresponde a la versión multifuncional FT80x/FT81x)

Las lineas de conexión para cualquier pantalla FT80x a un arduino Due son:

Code: [Select]
FT80x    Due
GND      GND
VCC      3V3
MOSI     MOSI
MISO     MISO
SCK      SCK
CS       pin digital disponible


Las lineas extra que tiene cualquier pantalla FT80x: INT y PD, no se usan en las librerias para gameduino 2.

Adicionalmente, la mayoría de pantallas FT80x no tienen un lector SD, y pocas tienen instalado el amplificador en la salida de audio.

Para adicionar un lector SD, se puede usar un lector microSD. En los experimentos previos para anexar un lector, me di cuenta que debe estar diseñado para 3.3V, y no debe tener instalado un regulador de voltaje 5V/3.3V. Para minimizar las fallas, cada linea debe unirse a las lineas MOSI/MISO/SCK de la  pantalla

La memoria micro SD recomiendo que sea de 4Gb, clase 4, preferentemente kingston, formateada en FAT32.

¿Por qué usar las librerias del gameduino 2, en lugar de las diseñadas por FTDI?. Es bastante simple.

Veamos el ejemplo hello world que viene en la libreria FTDI para el FT843



Code: [Select]
#include <SPI.h>
#include <GD2.h>

void setup(){ Serial.begin(1000000); // JCB
  GD.begin(0);}

void loop(){GD.ClearColorRGB(0x103000);
  GD.Clear();
  GD.cmd_text(GD.w / 2, GD.h / 2, 31, OPT_CENTER, "Hello world");
  GD.swap();}

Sketch uses 13,664 bytes (2%) of program storage space. Maximum is 524,288 bytes.

Creo que las diferencias son mas que evidentes.

No es solo conectar la nueva pantalla, hay que hacer algunos ajustes en la libreria GD2 para que las pantallas FT80x se comporten como lo hace la pantalla del gameduino 2.
Gracias por la información TFTLCDCyg. Esto he estado buscando todo el fin de semana y lo tenía delante de mis ojos (este mensaje tuyo)

Hoy me has alegrado el día.

Como bien sabes tengo la FT800 y después de leer tu post, creo que me he vuelto a animar, estaba totalmente aburrido y desilusionado. Te explico, he llegado a pensar que "no es tan difícil", pues si,  ya que la librería procedente de FTDI es extremadamente complicada, ademas he leído  los interminables PDF de la pagina oficial, en cuyos ejemplos, no me ha funcionado casi nada. Solo los ejemplos de las librerías.

Voy esta tarde a repasar todo tu post, le voy a poner mi DUE y conectar la pantalla que solo muestre el "Hola mundo".

Lo mas curioso es que veo esta pantalla (FT800) le da 100.000 vueltas a todas las que he probado, pero cachis, que va costar un rato hacerla andar. Bueno ya comentaré mi experiencia.

Saludos de nuevo y gracias! :)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 21, 2016, 11:14 am
Me olvidé de lo mas importante para ir trabajando;

Code: [Select]

Las lineas de conexión para cualquier pantalla FT80x a un arduino Due son:

FT80x    Due
GND      GND
VCC      3V3
MOSI     MOSI
MISO     MISO
SCK      SCK
CS       pin digital disponible


Las lineas extra que tiene cualquier pantalla FT80x: INT y PD, no se usan en las librerias para gameduino 2.


Donde dices CS pin digital disponible, a que pin a de ir? no me quedó claro.
Y otra cosa, sobre que IDE de Arduino funciona correcto, he leído que la versión 1.5.4, puede ser?
A ver si me puedes ayudar.
Gracias.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 21, 2016, 04:47 pm
Espero que te sirva y te evites la pena de sumergirte en el lenguaje complejo de las librerías de FTDI. Creo que iremos al paso aprendiendo a usar la libreria.

Estoy usando el IDE 1.6.3, y creo que me quedaré en esa versión. No tengo la versión 154, pero tengo la 156-r2, la librería de gameduino 2 funciona sin problemas. Habrá que experimentar.

Respecto al cableado: CS, puede ser cualquier pin digital disponible, te recomiendo que sea 8, 9 o 10. Pero creo que se puede usar cualquier otro (habrá que experimentar con este punto).

Por cierto, la libreria para gameduino 2 tiene una particularidad que debo reiterar:

Por código, tiene transportada la señal SPI del conector del arduino Due, a los pines SPI correspondientes al arduino UNO, es decir que puedes conectar la señal SPI de cualquier pantalla FT80x, a los pìnes 11, 12 y 13.

Es por esto que se puede conectar el shield gameduino 2 directamente sobre un arduino Due, tal como se conecta en el arduino UNO, sin cableado conectado al conector SPI del arduino Due.

(http://www.mediafire.com/convkey/3dde/fc39eiw1cxqckyfzg.jpg)

En el arduino MEGA hay que conectar los pines SPI a los pines correspondientes 11, 12 y 13, (creo que se podrían sustituir "los nombres de pila" de los puertos SPI del MEGA en lugar de los correspondientes del arduino Due) y con eso se consigue instalar el shield gameduino 2 directamente:

(http://www.mediafire.com/convkey/18f5/wl1y73ud56gufnqzg.jpg)

(http://www.mediafire.com/convkey/4faf/d322bxaccc6dqpbzg.jpg)

Puedes usar el cabezal SPI del arduino con otros dispositivos, como una pantalla Oled, ILI9341 o un lector micro SD adicional. Si los conectas a 11, 12, 13 pensando en usar "el porteo" o transferencia por código, se apaga la pantalla FT80x.

El único dispositivo SPI que ha funcionado sin afectar la pantalla, afortunadamente fue uno de los  lectores microSD de 3V3, y con él es posible acceder a todo el potencial gráfico del FT801.

La longitud del cableado entre el arduino y la pantalla FT80x, debe estar entre 14 y 20 cm, mas allá de esa longitud la pantalla se apaga.

(Una queja "oculta")

Desafortunadamente conforme salen nuevos ide's, en lugar de mejorarlos, y corregir errores, empeoran la compatibilidad con las librerias que funcionan bien con versiones previas. Encima no ha habido una corrección de fondo que elimine esta "joyita", si usas y0 ("ye cero"), seguido de un y1 ("ye uno"), obtienes:

Code: [Select]
int y0, y1;

Code: [Select]
GD2_due_lecturas_5.ino:11:5: error: 'int y0' redeclared as different kind of symbol
In file included from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\cores\arduino/Arduino.h:26:0,
                 from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\variants\arduino_due_x/variant.h:36,
                 from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\libraries\SPI/SPI.h:15,
                 from GD2_due_lecturas_5.ino:1:
c:\users\starx\appdata\roaming\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1\arm-none-eabi\include\math.h:468:15: error: previous declaration of 'double y0(double)'
 extern double y0 _PARAMS((double));
               ^
GD2_due_lecturas_5.ino:11:9: error: 'int y1' redeclared as different kind of symbol
In file included from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\cores\arduino/Arduino.h:26:0,
                 from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\variants\arduino_due_x/variant.h:36,
                 from C:\Users\StarX\AppData\Roaming\Arduino15\packages\arduino\hardware\sam\1.6.4\libraries\SPI/SPI.h:15,
                 from GD2_due_lecturas_5.ino:1:
c:\users\starx\appdata\roaming\arduino15\packages\arduino\tools\arm-none-eabi-gcc\4.8.3-2014q1\arm-none-eabi\include\math.h:469:15: error: previous declaration of 'double y1(double)'
 extern double y1 _PARAMS((double));
               ^
Error compiling.


¿Es en serio?

La siguiente linea, (en lugar de la que describo):
Code: [Select]
int x0, x1

Compila sin problemas... quiero tener la mente abierta y que es un error mío al escribir "y0 y y1"...

Digo esto porque luego de ver "hello world" en la FT801, inmediatamente me puse a trabajar en el entorno del controlador, y zas!, a la primer compilación con "int y0, y1", saltó el error que refiero.

Solo por seguir con el ejercicio, el IDE 1.5.6-r2, da este error:

Code: [Select]
int y0, y1;

Code: [Select]

sketch_jun21a:2: error: 'int y0' redeclared as different kind of symbol
c:\arduino-1.5.6-r2\hardware\tools\g++_arm_none_eabi\bin\../lib/gcc/arm-none-eabi/4.4.1/include-fixed/math.h:364: error: previous declaration of 'double y0(double)'
sketch_jun21a:2: error: 'int y1' redeclared as different kind of symbol
c:\arduino-1.5.6-r2\hardware\tools\g++_arm_none_eabi\bin\../lib/gcc/arm-none-eabi/4.4.1/include-fixed/math.h:365: error: previous declaration of 'double y1(double)'

:o  :o  :o  :o

Luego de esta "pecata minuta", mejor usaré
Code: [Select]
int y00, y01;
 y todos felices!

A estas alturas, espero que ya veas el ejemplo hello world. Sube algunas fotos de tu pantalla FT, para curiosear los avances, sería bueno ver que los esfuerzos los puede replicar alguien más, ayudaría bastante en la retroalimentación, nunca está demás una vuelta de timón hacia la dirección correcta.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 21, 2016, 07:36 pm
Buenas noticias!!!! , pero de las buenas.

He conseguido hacer funcionar mi pantalla comprada en esta tienda (http://www.hotmcu.com/5-graphical-lcd-touchscreen-480x272-spi-ft800-p-124.html?cPath=6_16). Llevo peleando con ella 3 días enteros (con sus noches incluidas, que no me han dejado dormir casi...) y como dije solo funcionaba con la librería de FTDI.

Pues bien también funciona con la librería GD2
Va le a todo esto sé que no tiene audio, acelerometro ni microSD, todo a su tiempo...

Esta pantalla tiene tiene una placa (shield) básica sin nada mas que operar solo con la librería FTDI, pues hay que realizar tan solo un circuito de POR (Power On Reset) al pin PD_N del chip FT800, resultado: FUNCIONANDO.

Cuando leí este mensaje de Gameduino (http://gameduino2.proboards.com/thread/179/newbie-advice-15khz-output-touchsc) me desanime por completo, ya que el usuario tiene el mismo problema que yo. He tirado de la DataSheet del FT800 a nivel del hardware FT800 DATA (http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT800.pdf) y aquí he logrado la solución.

Lo mismo se va a vender esta pantalla como rosquillas, lo digo por el precio y para iniciarse como yo, pues va bien para empezar.

@TFTLCDCyg creo, la pantalla ahora si que empieza a prometer.

Mas tarde escribo la solución, que me voy a tomar unas cervezas para celebrarlo.  :)  :)  :)

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 21, 2016, 08:28 pm
Que ya veas que sirva con la librería para gameduino 2, es un enorme avance. :smiley-draw:

Te sugiero que el siguiente paso lo apliques en encontrar un lector micro SD, que te dé el soporte para manejo de imágenes.

La librería puede manejar grupos de hasta 15 imagenes pequeñas, y lo mejor de todo: en formato png, con lo que puedes tener iconos o imagenes con transparencias!!!.

Esta pantalla puede funcionar con las librerías gráficas de phyton27, sin embargo no he podido hacer que funcionen. Quizás con una instalación limpia del sistema operativo lo pueda conseguir. Con esas herramientas activadas, es posible crear sprites en celdas de hasta 8 imagenes cada una. Por ejemplo se podrían construir archivos de imagen con digamos 5 imagenes png, con 8 celdas cada una, consiguiendo 5x8 = 40 imagenes con un solo archivo sprite. Espero un día instalar correctamente las librerias. Claro siempre estaremos limitados a los 256 kb del FT80x.

Aparentemente no es mucha memoria, pero eso no es una límitante que debilite la plataforma.

Video: iconos png (https://www.youtube.com/watch?v=45auLwBeFCs)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 22, 2016, 12:39 am
Buenas.

Como dije las pantallas chinas de bajo coste de esta tienda de China funcionan correctamente en la librería GD2 del cual, le doy las gracias por este post a TFTLCDCyg.

No hubiesen funcionado jamas  si no, después de releer mas de 20 veces el post completo.
Como tengo varios proyectos en mente acabo de realizar un pedido para no quedarme sin stoks cosa que ocurre cuando se escribe algo y todo el mundo pide...

He aquí la solución.

Quote
Las lineas extra que tiene cualquier pantalla FT80x: INT y PD, no se usan en las librerias para gameduino 2.
Adicionalmente, la mayoría de pantallas FT80x no tienen un lector SD, y pocas tienen instalado el amplificador en la salida de audio.
Para esta pantalla no es valido.

Esto anterior es lo que ha escrito @TFTLCDCyg en el caso de estas "pantallas Chinas de bajo coste" como la que yo he comprado supongo porque es asi, TFTLCDCyg las usa con shiels personalizadas como Gameduino, ADAM, y otras mas, por la red están sin stock, y entonces me puse a investigar este ultimo sábado de mes (día 18 del corriente) y sin conexion alguna.

Hoy he recuperado mi Arduino DUE y conectado el SPI de la pantalla. Totalmente negra... Sin nada.
Volvi a mi Arduino MEGA. Al menos sabía que funcionaba la librería FTDI y funcionando, la pantalla, seguía a la vida.

Pero por "arte de magia" o casualidad al intentar subir la hoja de ejemplo de la librería FTDI y luego seguido a los dos segundos el ejemplo de la librería GD2 con el consejo de TFTLCDCyg, visualice en unas fraciones de milisegundos que la pantalla ponia " HELLO WORLD" , entonces dije EUREKA!!!

solo unos milisegundos y funcionó, por lo tanto la pantalla funcionaría con la librería GD2.
Como lo adiviné?

Sencillo. Al principio de luchar con la pantalla descubrí que el pin llamado PD_N del circuito integrado grafico FT800 es no mas que un reset al chip anterior citado. Con esto funcionó cuando lo pusé en el pin correcto de la placa Arduino ( en modelo UNO y MEGA), vale entonces hoy el pin PD_N es MUY IMPORTANTE si no se tiene una shield adecuada como ha escrito TFTLCDCyg.

La solución es esta, hay que montar una red R+C al pin PD_N (o bien hacerlo exteriormente, como lo he realizado yo) como pone la DataSheet del circuito integrado FT800;

(http://i.imgur.com/nTrCwuR.jpg)

Donde VCCIO es 3,3V (MUY IMPORTANTE !!!) no conectar a +5VCC, hay que hacerlo a 3,3VCC

(http://i.imgur.com/mPBI8AL.jpg)

Resultado;

Montar la red R+C exterior;
(http://i.imgur.com/nAgkKnf.jpg)

Como quedo compilado con IDE de Arduino 1.6.5;

(http://i.imgur.com/RVtZQ8b.jpg)

y otra mas;

(http://i.imgur.com/vpxr1B8.jpg)

Al revés... bueno anteriormente TFTLCDCyg comento de modificar las librería...
Mañana lo pruebo ya definitivamente en mi Arduino DUE y pondré mas capturas. A todo ello voy a incluir esta información de "peso en oro" a mi mensaje ne Documentos de este foro para la pantalla china que es este enlace pantalla FT800 china (https://forum.arduino.cc/index.php?topic=406170.0)

Saludos!  :)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 22, 2016, 05:17 am
En la pantalla FT843 (FT800) de 4D systems, el propio gameduino 2 y en la FT801 de Riverdi, no he usado las lineas INT ni PD.

Como indicas es posible que el FT800 en tu pantalla, esté conectado de forma muy austera.

Esperemos que tengas funcionando correctamente tu pantalla en el arduino Due. Gracias por compartir los avances.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 23, 2016, 11:17 pm
Buenas.
Doy hoy por decir esto;

La pantalla  FT800 de este modelo;
(http://www.haoyuelectronics.com/Attachment/FT800CB-HY43B/FT800CB-back-1.jpg)

comprada en esta tienda de Hong-Kong (http://www.hotmcu.com/5-graphical-lcd-touchscreen-480x272-spi-ft800-p-124.html?cPath=6_16) funciona correctamente con la librería GD2.

Ayer tube problemas...
La monté sobre mi Arduino DUE y no funciono... la volví a poner sobre mi Arduino MEGA y funcionaba( tal y como la tenía), pero solo una cosa, solo funcionaba con el codígo del ejemplo del "Hello World" ( a partir de ahora "HELLOWORD"

Este es el código que funcionaba con realizar el POR (Power On Reset);

Code: [Select]

#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>


void setup(){

  GD.begin(0);

}

void loop()
{
  
  GD.ClearColorRGB(0xff0000);
 
  GD.Clear();
  GD.cmd_text(GD.w / 1, GD.h / 2, 31, OPT_CENTER, "HOLA TOMAS F.");
  GD.swap();
}


Todo bien, pero al cargar desde la librería un ejemplo de código como este;

Code: [Select]

#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>

void setup()
{
  GD.begin();
}

void loop()
{
  GD.Clear();
  GD.Begin(POINTS);
  for (int i = 0; i < 100; i++) {
    GD.PointSize(GD.random(16 * 50));
    GD.ColorRGB(GD.random(256),
                GD.random(256),
                GD.random(256));
    GD.ColorA(GD.random(256));
    GD.Vertex2ii(GD.random(480), GD.random(272));
  }
  GD.swap();
}



Este último se queda la pantalla en fade (desvanecimiento), resetear y/o volver a conectar el cable de alimentación.. lo mismo pantalla blanca y desvanecimiento... Esto toda la tarde ayer me frusto de lo GRANDE...

Hoy he recuperado la ilusión. La única diferencia de un código a otro esta en setuo donde el código "bueno" pone;

Code: [Select]

GD.begin(0);


y en el segundo pone;

Code: [Select]

GD.begin();


y este es el problema el GD.begin (sin numero);... he ido probando mas ejemplos como los de las librerias y ya funcionando todas (algunas no por el IDE de Arduino, como no.. jejeje), estoy usando la 1.6.5

a todo esto en el setup de cualquier código para subir he investigado esto:

Code: [Select]

GD.begin();   ---> PANTALLA BLANCA y no funciona nada en pantalla. Desvanecimiento y rayas.
GD.begin(1) funcional, pero baja resolución
GD.begin(2) funcional y Táctil
GD.begin(3) funciona, Táctil y gráficos a máxima resolución
No he probado mas por falta de tiempo...


Y otra buena noticia

he conseguido por software realizar el POR (Power On Reset) de la pantalla realizando este código:

Code: [Select]

#define PDNPin 8
...

En el setup:
  pinMode(PDNPin, OUTPUT);
  digitalWrite(PDNPin, HIGH);  
   delay(20);
  digitalWrite(PDNPin, LOW);
  delay(20);
  digitalWrite(PDNPin, HIGH);
  delay(20);


Consultando las DataSheet del IC FT800, necesita unos 5ms desde el inicio de pantalla que paje a nivel bajo y vulta a nivel alto, lo he recogido de la pagina oficial y ponía estos delay, lo mismo se trata de substituir por delayMicroseconds.

De momento y a esta pantalla también he averiguado que los colores parpadean y/o son inverson del rojo al azul. La solución es poner en el setup este código después del GD.begin(x);

Code: [Select]

GD.wr(REG_SWIZZLE, 0);


No he leído la extensa y grandísimo PDF de la librería GD2 pero, no acabo de ver por el cual el GD.begin(x) era el problema.... Seguiré investigando pero ya digo que la pantalla en totalmente funcional. Lo siguiente y tengo los componentes le voy a poner el audio y una SD, realizada por mi.

Dejo el código tipo INICIAL (luego ustedes programan lo que sean...) de como queda la pantalla para Arduino UNO y MEGA;

Code: [Select]

#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>

#define PDNPin 8                   // PIN DONDE VA EL PIN_DN

void setup(){

 
   pinMode(PDNPin, OUTPUT);
   digitalWrite(PDNPin, HIGH);  // INICIALMENTE EN ALTO
  
   delay(20);
   digitalWrite(PDNPin, LOW);  // REALIZAMOS EL POR EN BAJO AL PIN DN
   delay(20);                        // ESPAREMOS 20 MICROSEGUNDOS (Data pone 5ms)
   digitalWrite(PDNPin, HIGH);  // LO VOLVEMOS A PONER EN ALTO
   delay(20);
   GD.begin(3);
   GD.wr(REG_SWIZZLE, 0);   // PARA NO INVERTIR EL ROJO POR AZUL DE LA PANTALLA


}

void loop()
{
  
   GD.ClearColorRGB(0xff0000);   // LA PANTALLA DE FONDO ROJO
   GD.Clear();
   GD.cmd_text(GD.w / 1, GD.h / 2, 31, OPT_CENTER, "HOLA TOMAS F.");
   GD.swap();
}


@TFTLCDCyg no quiero desorientar este tema tuyo, pero tenía que explicar, luego lo realizo en mi tema que puse en "DOCUMENTACIÓN" de esta pantalla para consultas. A todo ello me respondió el Admin de Gameduino. Le pondré la solución por software al pin PD. Y repito sin tus mensajes esta pantalla no hubiese jamas funcionando en GD2, esto se le llama "team" no?

Saludos.
P.D. Mañana voy a probar con el DUE, ahora que sé que es todo correcto.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 24, 2016, 07:01 am
Al contrario, gracias por el aporte y es bienvenido las veces que gustes compartir. Esas pantallas las vi hace bastante tiempo, pero por falta de recursos no me pude hacer con una. Decidí ahorrar un par de veces para conseguir la FT843 (un FT800) de 4D systems porque me agradó el diseño del shield para arduino. Batallé mucho con la libreria FTDI.

Luego conseguí un gameduino 2 y me sumergí en su libreria, pude ver el potencial de la pantalla.

Todo el tiempo quise una pantalla capacitiva de Riverdi, mas que nada por el tema dela tecnología que ellos usan en el cristal táctil, pero el costo era algo prohibitivo. No obstante decidí esperarme un rato y averiguar como podía conseguir una pantalla hecha en Polonia hasta México!!!.

Varias de las ideas que has podido implementar voy a tratar de usarlas en la pantalla FT813 (un caprichito mas, jejejeje), para ver si logro hacerla funcionar con la GD2, la librería de FTDI me "cansa los ojos". (con ella aprendí bastante pero no tanto como con la librería del gameduino2)

Gracias por los consejos, es la idea de este post.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 27, 2016, 12:47 am
Otras buenas noticias!

Siguiendo tus consejos @TFTLCDCyg me he fabricado una placa para obtener una tarjeta lectora a MicroSD construida a través de un adaptador de SD desde este esquema;

(http://i.imgur.com/N8lDbKW.jpg)

Estoy en la espera de tres tipos diferentes y tardarán en llegar todavía. El problema creo que es el integrado "latches" que tienen. Ademas no creo es problema del regulador de 5 -> 3,3 Voltios, el problema es el IC

De momento funciona correctamente.
Así ha quedado;

(http://i.imgur.com/Z2QUjHc.jpg)

(http://i.imgur.com/sDV4NS0.jpg)

(http://i.imgur.com/6eAsSNd.jpg)

He seguido tus pasos y darte las gracias por el programa GD2asset para traspasar los ficheros a la librería GD2. Estuve ayer toda la tarde intentando lograrlo en Win desde instalar Python y no funcionó, en Linux si, pero repasé este tema en la segunda pagina, y todo decir que ya lo tengo guardado en mi Pendrive de "ORO".

Tengo muy claro que no voy jamas a comprar un LCD -alfanumérico-, gráfico monocromo ni nada parecido ni los LCD con controlador ILxxxx etc. Lo tengo a partir de hoy muy claro que los LCD pasan con Arduino a pantalla con chip FT8XX. Lo demás es tirar dinero y perder tiempo.

Es algo que si no lo experimentas no sabes del potencial. Mira una cosa tan grande al menos claro cuando yo me decido por comprar esta pantalla de bajo coste que te comente para experimentar. ya sé que hay shields para ella a precios prohibitivos, sin embargo ya le tengo puesto la SD, ahora toca el audio y esto va ser fácil.

(http://i.imgur.com/DM97eH9.jpg)

(http://i.imgur.com/JfiRcNY.jpg)

Fácil si lo interpretas bajo que uno sabe de Electrónica, consultas esquemas, DataSheet y vas montando todo lo que hace el fabricante de placas (Shields) claro a nivel personal y entiendo que no todo el mundo sabe realizarlo, por lo tanto he aquí el gasto de los 100$, ahora lo entiendo, para mi esto es tirar dinero y es mas cuando sabes interpretar un esquema lo pones en practica y a funcionar.

No sé exactamente donde voy a llegar con estas pantallas, de hecho ya tengo pedida otra igual y dos FT812 (Capacitivas con resolución 800x480) será otro mundo!!!. jejejeje

No me cansó en darte las gracias en tu aportación de este GRAN post tuyo @TFTLCDCyg, posiblemente lo próximo será decirte que ya tengo funcionando el audio también (que por cierto, le tengo ya ganas probando lo que da la pantalla), los que no lo han probado esta pantalla , ni se imaginan de SERIE lo que esto hace...  Bueno lo que hace la librería GD2, se supone que no es para crear una consola... entonces sería perder tiempo y dinero. Lo que no le voy hacer de momento es tener un acelerometro, porque lo veo a mi modo inútil, a mi no me sirve. No esta en mis proyectos.

A todo esto una consulta..
El programa GD2asset sirve también para transformar los archivos de audio a IMA?
Si es así como pone en la pagina oficial de Excamera?

A todo esto, voy a realizar una placa PCB (shields) tanto para Arduino UNO y MEGA, donde solo se pondrán conectores. Y/o bien el modulo de audio y la SD estén integradas a la misma placa. Realizaré los fotolitos y de esta forma quedará sin cables y le pondré extras como BUS i2C y las entradas analógicas sobre todo.

Sin comentarios mas, voy a seguir con esta magnifica pantalla.
Saludos!!!  :)




Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 27, 2016, 02:08 am
Que bien que vas progresando con el experimento. De hecho los nuevos lectores microSD los construí con soportes como los de tu experimento, solo que no los he probado, básicamente por que no me quiero cargar mi lector microSD de 4Gb (que también es de oro jejejeje)

Respecto a las pantallas FT81X, la que al parecer funciona al 100% con la libreria GD2, es la FT810C.

No he podido conseguir que la FT813 responda con la libreria GD2, pero si con los ejemplos base de FTDI, quiero hacer funcionar el lector SD y verificar como funciona la app para reproducir videos!!!.

Por cierto, para conseguir mejores resultados conecta el lector microSD, al mismo bus SPI de la pantalla FT, he notado que al usar al SPI normal del Due luego de un tiempo las imagenes se corrompen, traté acortando los cables pero no funciona, deben ser 11, 12 y 13 forzozamente.

Solo la instalación para Phyton 27 del GD2asset permite convertir los archivos de audio. La básica para windows solo sirve para arreglos de imagenes. Es posible que la instalación para linux si funcione para convertir audio en el formato que se necesita.

PD: se podría experimentar con los programas de conversión de audio que sugiere FTDI.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 27, 2016, 09:17 am
Por cierto, para conseguir mejores resultados conecta el lector microSD, al mismo bus SPI de la pantalla FT, he notado que al usar al SPI normal del Due luego de un tiempo las imagenes se corrompen, traté acortando los cables pero no funciona, deben ser 11, 12 y 13 forzozamente.
Tienes razón. Esto me paso varias veces y tener que formatear la SD.
Usando Arduino MEGA, la pantalla la tengo en los pin´s 51,52,53 y el lector en el conector ISCP y experimentaré de tenerlo todos juntos.

Descargue las aplicaciones de herramientas de FTDI de conversiones y sin llegar a probarlas. Lo tendré en cuenta. En cuanto terminé de ponerle el audio, experimentaré entonces con Arduino DUE. Sobre el audio según la DataSheet que viene con su esquemas, creo en un principio, no deja de ser una etapa de BF con un filtro de tercer orden a su entrada y no habrá problemas, es una etapa solo, ya le tengo realizado uno con un LM386 para probar.

Acabo de revisar las nuevas pantallas y son;  5" Graphical LCD capacitive touch screen, 800x480, SPI, FT811



Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 27, 2016, 01:49 pm
...Acabo de revisar las nuevas pantallas y son;  5" Graphical LCD capacitive touch screen, 800x480, SPI, FT811
Esos ejemplos que sugieren como usar la pantalla me dan mucho que pensar, creo que por un rato tendremos que estar sumergidos en las instrucciones originales de FTDI para arduino.

Lo mismo ha hecho Riverdi con sus FT81x.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 28, 2016, 06:54 pm
Ahora viene "la prueba pesada" para saber si el lector micro SD se mantiene estable o tengo que experimentar con los "lectores micro SD hechos en casa".

Este es el lector microSD comercial que ha funcionado sin problemas con las pantallas FT80x que he experimentado y que no cuentan con ese elemento:

- Lector micro SD de 3.3V (http://www.chinalctech.com/index.php?_m=mod_product&_a=view&p_id=646)

(http://www.mediafire.com/convkey/c7f9/1n87j8740e1g0y5zg.jpg)

El break out catalex, me ha dado muchos problemas de estabilidad, a veces funciona y otras parece que interfiere con el inicio de la pantalla. Para evitar algun fallo en el cableado, decidí soldar algunos cables  en un cabezal de 6 pines, para allí conectar el lector de 3.3V que ha resultado mas estable

(http://www.mediafire.com/convkey/3f22/2du351y1yaln9aazg.jpg)

La prueba consiste en cargar un archivo con 12 iconos png de 48x48 cada uno, así como una imagen jpg de 480x156 px, desde el lector micro SD.

Para complicar la prueba, cada icono será escalado a un 40% de su tamaño, y se mostrará en patrones de movimiento circular; cada icono con su propio ángulo inicial y centro de rotación.

La imagen jpg servirá como fondo de pantalla.

Luego de unas 3 horas continuas, aplicaré un reinicio manual en el arduino, incluso he pensado en desconectar/conectar la alimentación. Veremos si este break out de 3.3V cumple las expectativas.

(http://www.mediafire.com/convkey/0ef5/6cdwv1kwyxhkgalzg.jpg)

Skecth e imágenes usadas en la prueba (http://www.mediafire.com/download/0r193psp7x7c2w3/GD2_FT801_iconos1.rar)

Me aplico en el trabajo y dejaré la prueba en proceso, ya veremos mas tarde como se comporta el experimento.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 29, 2016, 01:40 am
Heeeeee ...
Descargado y lo pruebo.

Realizo pruebas y te digo como se comporta.

Acabo de terminar mis placas, que no han sido realizar unos PSB´s, por aquí ya hace mucha calor y yo cpn ella me da pereza realizar, hasta levantarme... Pero a todo ello he realizado con dos placas 2,54 mm unos conectores y ya esta funcionando la pantalla.

A todo esto el "lector" microSD de cosecha propia, el mismo que puse en el mensaje anterior y funciona al 100 por 100. Te comento con va la cosa.
Bye!

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 29, 2016, 07:55 am
Espero que funcione el lector de "cosecha propia", es una excelente opción para usar los adaptadores micro SD que sobran.Ya nos contarás cómo te fue con la prueba.

Luego de unas 5 horas y fracción, detuve la prueba de estabilidad. El lector micro SD logró superarla.

Video: fin de la prueba (https://www.youtube.com/watch?v=s3UefAVuhaA)

PD: la calidad de las imágenes es muy superior a la mostrada en el vídeo, parece que la cámara no le hace justicia a la pantalla, los colores son mas intensos y con muy buena resolución, a pesar de la escala empleada para dibujar los iconos. No parece una pantalla que tenga una resolución teórica de 480x272 pixeles!!!.

Como dije alguna vez: las pantallas FT8xx son las mejores pantallas para arduino que he visto hasta el momento.

Sé lo que les digo...
(http://www.mediafire.com/convkey/0fdd/d8k8mksy6p9ajlrzg.jpg)

No son fáciles de poner a punto, pero con la librería para gameduino 2, tenemos andado casi el 60% del camino. El resto es solo dejar volar la imaginación.

Por cierto, aunque tenemos placas arduino de formato pequeño, como el Pro o el mini, no me terminan por convencer los 5V y su velocidad, veo con agrado que el test para el FT801, compila sin errores para el teensy 3.2, ya veremos como funciona cuando arme el shield de conexión

(http://www.mediafire.com/convkey/c614/3ayc2cw1s2z9rljzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 29, 2016, 08:35 am
Hay que tener cuidado con el IDE de arduino, el sketch de la prueba compila sin problemas para arduino Due en el IDE 163, sin embargo si se selecciona la placa UNO, MEGA o Pro, se producen errores de compilación.

En el IDE 156-r2, el sketch de prueba compila sin problemas, tanto para el Due, como para placas AVR.

(http://www.mediafire.com/convkey/72f7/sm6hhiss8zbugeqzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 29, 2016, 09:58 am
Buenas.

Yo creo que solo hay un problema. El coste del LCD. Si lo realizas como yo, sale mas económico, pero hay que invertir en la experiencia personal, los conocimientos de electrónica y sobre todo tener paciencia.

Este es el gran hándicap de estos LCD´s, no es fácil cuando lo tienes por primera vez. Otro día realizo una captura de todos mis LCD´s, algunos de ellos de pisapapeles han quedado. Cambiado de tema, me da la impresión que el FT800 como chip me refiero al propio circuito integrado, su conexión SPI es muy delicada, casi apostaría que su problema es el ruido generado con el conexionado del mismo, dependiendo de su longitud, calidad de los cables, se obtienen errores, me ha pasado sobre todo con los cables tipo "chinos" que no son de cobre. En el trabajo tengo conectores flex pero los tengo que adaptar debido a su numero de pins, actualmente en mi LCD usa 12.

Incluso he llegado a pensar en apantallar los tres cables de control SPI (MISO, MOSI y SCK) y ver que resultado se obtiene. Lo digo debido al trabajo con pantallas LCD de 40 pulgadas hacia arriba, el conector LVDS casi la mayoría o antiguos se realiza de esta forma para no generar ruido por ejemplo a los 3 Buses de control que reciben las placas T-Con y algunas actuales hasta mas.

Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 29, 2016, 11:21 am
Por cierto TFTLCDCyg, estoy recopilando información sobre comandos de la librería GD2, pues me interesa.
Te hago una proposición constaría de realizar ir recopilando lo que no vienen en el Book de James, aunque es extenso y bien explicado, el Book no esta del todo completado.

He leído por ejemplo;

Code: [Select]

GD.wr(REG_SWIZZLE, 0);       // Inventir color Rojo (0xff0000) por Azul (0x0000ff)
GD.wr(REG_PWM_DUTY, 95);  // Valor para Dimmer del BackLight (Entre 0-128)


Esta es la idea. Que te parece?
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 29, 2016, 03:24 pm
Incluso varias veces James ha dicho que se debe cuidar mucho la longitud de los cables. En el teensy es aun mas restringido: la longitud no debe superar los 10 cms.
(http://www.mediafire.com/convkey/2a6b/yg6lxgjxqbc454pzg.jpg)

Es algo curioso, la librería FTDI tolera mayor longitud
(http://www.mediafire.com/convkey/0429/i0bi36nh8h8hbn3zg.jpg)

De acuerdo con tu idea. Hay otro:

Code: [Select]
GD.play(0); //detiene ruidos o sonido en altavoz
El argumento 0, es idéntico a emplear SILENCE

Respecto al uso de tags, cualquier objeto que se dibuje en pantalla puede ser usado como entrada táctil.

Por ejemplo una linea, una palabra o un polígono.

Code: [Select]
GD.Tag(1);   po.begin();  po.v(16*(0+movx),16*0);   
po.v(16*(140+movx),16*0);  po.v(16*(80+movx),16*60);   
po.v(16*(0+movx),16*60);  po.draw(); GD.Tag(255);


Para evitar que el mismo tag se asigne a varios objetos, o bien se combinen en un mismo objeto, recomiendo colocar la instrucción:
Code: [Select]
GD.Tag(255);
Al final de cada linea que asigna un número de tag

El tag "0"
Code: [Select]
GD.Tag(0);

Causa errores en los tags definidos en la misma pantalla, recomiendo no usarlo.
Title: Re: Algunos consejos para usar TFT´s
Post by: davissanchez on Jun 30, 2016, 02:58 pm
Muchas gracias por los consejos :)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 07, 2016, 06:47 pm
Gracias davissanchez. Espero que esté sirviendo de apoyo. Mas adelante subiré algunos ejemplos para pantallas como la ILI9341@16 bits de 3.2".

Carga de una sola imagen JPG en las pantallas FT80x

Una de las ventajas de los chips FT80x (y espero que en el FT813!!!), es la carga de imagenes jpg.

Con la libreria FTDI este es el proceso:

Code: [Select]
#include "SPI.h"
#include "Wire.h"
#include "FT_VM801P43_50.h"

FT_SD FtSd(FT_SD_CSPIN);
FT_SDStatus sd_present;
FT_SDFile Imagefile;

FT801IMPL_SPI FTImpl(FT_CS_PIN,FT_PDN_PIN,FT_INT_PIN);

#define MAX_IMAGES  6
char imagename[MAX_IMAGES][12] = {"autumn.jpg","daisy.jpg","empire.jpg","fred2.jpg","pencils.jpg","tulips.jpg"}; // all are wav files
int IDimagen = 4; //image index

/* Api to bootup FT801, verify FT801 hardware and configure display/audio pins */
/* Returns 0 in case of success and 1 in case of failure */
int16_t BootupConfigure(){
 uint32_t chipid = 0;
 FTImpl.Init(FT_DISPLAY_RESOLUTION);//configure the display to the WQVGA

 delay(20);//for safer side
 chipid = FTImpl.Read32(FT_ROM_CHIPID);
 
 /* Identify the chip */
 if(FT801_CHIPID != chipid)
 {
 Serial.print("Error in chip id read ");
 Serial.println(chipid,HEX);
 return 1;
 }
 
 /* Set the Display & audio pins */
        FTImpl.SetAudioEnablePin(FT_AUDIOENABLE_PIN);
 FTImpl.DisplayOn();
 FTImpl.AudioOn();
 return 0;
}

/* Display an on-screen message if the storage device is not found */
void CheckStorageDevicePrecence(){
 while(sd_present){
 FTImpl.DLStart();     
 FTImpl.Clear(1,1,1);
 FTImpl.ColorRGB(255,255,255);
 FTImpl.Cmd_Text(FT_DISPLAYWIDTH>>1,FT_DISPLAYHEIGHT>>1,29,FT_OPT_CENTER,"STORAGE DEVICE NOT FOUND");
 FTImpl.DLEnd();
 FTImpl.Finish();
 delay(5000);
 }
}


void setup()
{
 /* Initialize serial print related functionality */
 Serial.begin(9600);

 /*Initialize the SD object. Screen error message can only be displayed when the FT801 is ready*/
 sd_present = FtSd.Init();
 
 /* Set the Display Enable pin*/   
 Serial.println("--Start Application--");
 if(BootupConfigure())
 {
      //error case - do not do any thing
 }
   else
 {
     CheckStorageDevicePrecence();
             OpenJPGSD();  //Put image on GRAM from microSD
             ObjetcsJPG();
 }
 Serial.println("--End Application--");
}

void loop(){}

//Put image on GRAM from microSD
void OpenJPGSD()
{
    FtSd.OpenFile(Imagefile,imagename[IDimagen]);
    FTImpl.WriteCmd(CMD_LOADIMAGE);
    FTImpl.WriteCmd((1 ? 131072L : 100));
    FTImpl.WriteCmd(320L*2*194);       //320x194
    Load_Jpeg(Imagefile);
}

/* Apis used to upload the image to GRAM from SD card*/
void Load_Jpeg(FT_SDFile &r)
{
  uint8_t imbuff[512];
  uint16_t blocklen;
  while (r.Offset < r.Size)
  {
    uint16_t n = min(512, r.Size - r.Offset);
    n = (n + 3) & ~3;   // force 32-bit alignment
    r.ReadSector(imbuff);
    FTImpl.WriteCmd(imbuff,n); /* copy data continuously into command memory */
  }
}
//Put image on GRAM from microSD

//load image from GRAM
void SeeJPG()
{
    FTImpl.BitmapHandle(1);
    FTImpl.BitmapSource((1 ? 131072L : 100));
    FTImpl.BitmapLayout(FT_RGB565,320L*2,194);                     //320x194
    FTImpl.BitmapSize(FT_NEAREST,FT_BORDER,FT_BORDER,320,194);     //320x194
    FTImpl.Begin(FT_BITMAPS);
    FTImpl.Vertex2ii(0, 0,1, 0);   

//load image from GRAM


void ObjetcsJPG()
{
 do
  {
   FTImpl.DLStart();
   FTImpl.ClearColorRGB(0,15,0); // background
   FTImpl.Clear();
       
       SeeJPG(); //load image from GRAM

   FTImpl.DLEnd();
  }
  while(1);   
}

(http://www.mediafire.com/convkey/f5d3/dztytpzyg31x0epzg.jpg)
La imagen se presenta en la orientación "de fábrica" del chip FT801.

En la libreria para el gameduino 2, basta con aplicar la siguiente secuencia de instrucciones:

Code: [Select]
#include <SPI.h>
#include <GD2.h>

void setup()
{
  GD.begin();
  GD.cmd_loadimage(0, 0);
  GD.load("pencils.jpg");
}

void loop()
{
  GD.ClearColorRGB(0,15,0);
  GD.Clear();
    GD.Begin(BITMAPS);
    GD.Vertex2ii(0, 0);
  GD.swap();
}

(http://www.mediafire.com/convkey/3b1a/j2467f0rm7xwuc7zg.jpg)
La imagen se presenta de acuerdo a la orientación de la pantalla gameduino 2.

La diferencia en la complejidad para el manejo en ambas librerías es mas que evidente.

Aunque el shield Riverdi para arduino lo he podido hacer funcionar con la libreria para gameduino, prefiero usar el adaptador de 20 pines con el shield casero, ya que el cable plano no está forzado.

(http://www.mediafire.com/convkey/17f6/n463sb5l00doomlzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 08, 2016, 06:56 am
Indicadores analógicos en pantallas ILI9341

He retomado algunos proyectos que había dejado en pausa, entre ellos está el de dibujar indicadores analógicos. Por falta de tiempo y de aplicarme escribir para dar con un código que pudiese generalizarse a otras librerías. Quizás falte algo de optimización, pero eso ya lo dejo a los expertos.

Traté de elaborar un sketch lo mas simple posible, que permitiese manipular casi todos los elementos del gauge:

Marcas externas: número total, largo, color
Linea segmentada indicadora: número de segmentos, largo de cada segmento, color
Gauge: posición relativa, ángulo de inicio lateral
Orientación: horizontal (fija, para la versión vertical hay que hacer algunos ajustes, versión aun en el papel)

El color de fondo de las lineas segmentadas puede modificarse desde la tabla de definición de colores
Code: [Select]
#define Personal tft.color565(60, 60, 60)

Librería y hardware

Las librerias base son
Code: [Select]
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"

 - Pantalla : shield TFT ILI9341 de 2.8" (https://www.adafruit.com/products/1651)
- Arduino UNO

Uso de las funciones

Las funciones de dibujo del indicador analógico de linea segmentada son dos. La primera dibuja los marcadores externos del gauge y la segunda dibuja el indicador móvil.

Marcas externas
Code: [Select]
//(número de marcas indicadoras, x,   y,   color, radio max, largo de las marcas, grados bajo horizontal)
//               GaugeH(10,      85, 150,  WHITE,   65,          4,                     40);  1


Linea segmentada del indicador principal
Code: [Select]
// GaugeH1(medida_1,   85, 150,   RED,         65,           50,                           15,                    40);   
//        (variable,   x, y,    color dial,   radio max, número de marcas en el gauge, espesor del gauge, grados bajo horizontal)     

Creo que el sketch puede extenderse a otras librerías, con algunos ajustes en las instrucciones para dibujo de lineas.

Observaciones

1. Los valores que deben coincidir entre la función de las marcas externas y la función que dibuja la linea segmentada del gauge son:

Code: [Select]
x, y = centro de la circunferencia base del indicador analógico,
radio máximo de la circunferencia
grados bajo la horizontal


Los demás parámetros dependerán del gusto del diseñador

2. Recomiendo colocar la función que dibuja las marcas externas en la zona del sketch que se carga solo una vez. La función de dibujo del indicador segmentado debe colocarse en la zona del sketch que se repite indefinidamente.

Recomiendo usar funciones cíclicas en lugar del void loop, así es posible llamar por vez funciones con su propio ciclo de trabajo.

Code: [Select]
void Principal()
{
//instrucciones que se ejecutan solo una vez
 tft.setRotation(1);
 tft.fillScreen(BLACK); 

//       (número de marcas indicadoras, x, y,   color, radio max, largo de las marcas, grados bajo horizontal)
// GaugeH(10,                          85, 150, WHITE,   65,          4,                     40);  //Marcas del gauge 1
   GaugeH(10, 85, 150, WHITE, 65, 4, 40);  //Marcas del gauge 1
   GaugeH(6, 245, 100, WHITE, 35, 2, 0);  //Marcas del gauge 2   
   GaugeH(6, 245, 230, WHITE, 50, 2, -40);  //Marcas del gauge 3     
//instrucciones que se ejecutan solo una vez
 
//instrucciones que se ejecutan repetidamente
 while(1)
 { 
  medida_1 = analogRead(0);
  medida_2 = analogRead(1);
  medida_3 = analogRead(2); 

   tft.setTextSize(4);
   tft.setTextColor(RED,BLACK);
   sprintf(TX,"%04d",medida_1);
   tft.setCursor(40, 30);   tft.print(TX);
   GaugeH1(medida_1, 85, 150, RED, 65, 50, 15, 40);  //gauge 1
// GaugeH1(medida_1, 85, 150, RED,         65,           50,                           15,                    40);  //gauge 1   
//        (variable,   x, y, color dial, radio max, número de marcas en el gauge, espesor del gauge, grados bajo horizontal)     
   
   tft.setTextSize(4);   
   tft.setTextColor(GREEN,BLACK);
   sprintf(TX,"%04d",medida_2);
   tft.setCursor(200, 15);   tft.print(TX);   
   GaugeH1(medida_2, 245, 100, GREEN, 35, 30, 10, 0);  //gauge 2   
 //    (variable, x, y, color dial, radio max, número de marcas en el gauge, espesor del gauge, grados bajo horizontal)   

   tft.setTextSize(4);   
   tft.setTextColor(YELLOW,BLACK);
   sprintf(TX,"%04d",medida_3);
   tft.setCursor(200, 130);   tft.print(TX);   
   GaugeH1(medida_3, 245, 230, YELLOW, 50, 15, 15, -40);  //gauge 3     
//    (variable, x, y, color dial, radio max, número de marcas en el gauge, espesor del gauge, grados bajo horizontal)     
 }
//instrucciones que se ejecutan repetidamente
}

(http://www.mediafire.com/convkey/8d54/6l7de94ivx8bdhozg.jpg)


Ejemplo de uso (http://www.mediafire.com/download/dm2b6dd814g88wq/UNO_ILI9341_test_3_gauge_segmentado.rar)

PD: la clave para dibujar los indicadores analógicos son las funciones trigonométricas seno y coseno, no es dificil usarlas, solo hay que imaginarse como debería verse la linea segmentada y hacer uno que otro cálculo en papel.

Respecto a "los grados bajo la horizontal", ajusté las funciones para que se puedan dibujar incluso grados por encima de la horizontal, así que mas bien debería ser: "grados respecto a la horizontal".
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 14, 2016, 12:17 am
Buenas noches @TFTLCDCyg

Ayer recibí mis dos pantallas FT811CB y otra FT800CB desde Singapore de la Tienda THAOYU Electronics (http://www.hotmcu.com/)y ya estoy por probar la primera. Estoy ya terminando mi proyecto Radio FM-RDS para pasar a la acción de estas nuevas pantallas.

Solo decir que el vendedor es excelente y muy buen cuidado en envoltorio y ademas el precio superaba los 106$ y lo puso como 12$ y en Europa no me costo tasas!!!  :) compré 6 microSD en la misma a 0,70$ pin a pin una de ellas comprobada esta mañana y prefecto..

También realice un amplificador de BF para las pantallas y obtenía ruido a cierta frecuencia, tengo un analizador de audio en el trabajo, pero dejo de funcionar, creo que realizando el amplificador original de FTDI lo obtendré sin embargo tendré que realizar 4 (las 4 pantallas que ahora tengo).

Una de las posibilidades (que he adquirido también el integrado original TPA6205A1) con DGN - 8 PIN MSOP que es para estudiar... Bueno tengo un adaptador para realizar el circuito I.C.
 y sobre todo le pondré un buffer y a las malas con un operacional cortar las frecuencias siempre y cuando analice las que he de filtrar, quizás lo realice con un programa de PC de calidad y ya he visto varios...

No he visto la calidad que presenta la FT8111, pero ya he visto proyectos con EYE2, por ejemplo de un player MP3 que deja la boca abierta. Poco a poco. Me recuerda muy mucho a Kodi en sus bibliotecas de  sonido (OSMC) del cual soy muy adicto.

Dejo unas capturas de los LCD´s.

(http://i.imgur.com/xy68rfP.jpg)

(http://i.imgur.com/OUndKyZ.jpg)

(http://i.imgur.com/YPmbF2r.jpg)

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 22, 2016, 06:41 am
Llegaron muy bien protegidas esas FT8xx. Para el FT800 la mejor librería es la del gameduino 2.

Hay que explorar a fondo la actualización de esta librería, ya que de acuerdo con James, tiene soporte para las pantallas FT81X. Nos debería funcionar al 100% tanto en la FT813, como en tu flamante FT811.

Aun no he podido usarla en el FT813, probablemente debido a los registros de inicio.

Para entender como funciona el controlador FT81X, estoy explorando el funcionamiento de la libreria que subieron hace unos días los ingenieros de RIverdi, en la página del shield para arduino Arduino, que se supone que funciona para toda la familia FT8xx.

Primeras pruebas con el FT813

Conecté el shield-Riverdi-FT8xx, en un arduino Due. La libreria viene ajustada para el FT813, y en general me parece que está optimizada para la serie FT81X, con las pantallas FT80X, he detectado que hay intermitencias en la pantalla, la librería no es estable.

Para la familia FT80X, es mejor usar la librería previa que ellos ya tenían y que no sé por que razón eliminaron. Tengo respaldada esa librería, tiene todos los ejemplos de FTDI:

FT80X_Arduino (http://www.mediafire.com/download/1ysc11uv14m13xe/FT80X_Arduino.rar)

(Reitero mi sugerencia: usar la libreria gameduino 2 para la serie FT80X)

Ésta es la librería en la que estoy trabajando para los controladores FT81X (FT810, FT811, FT812, y FT813)

FT813_lib (http://www.mediafire.com/download/bifs8tgefiyopqr/FT813_lib.rar)

El conexionado corresponde al que tiene el shield-Riverdi-FT8XX:

Code: [Select]
#define FT800_PD_N          (8)
#define FT800_CS (10)
#define FT_SDCARD_CS (5)


Adicionalmente: SCK, MOSI, MISO, GND, VCC a 3V3. En cuanto me sea posible, conectaré el FT813 mediante el adaptador de 20 pines, para revisar a fondo si hay algún otro pin que se deba conectar.

FT800 de 3.5"
(http://www.mediafire.com/convkey/c74c/nk8422kn72r7mwlzg.jpg)

FT801 de 4.3"
(http://www.mediafire.com/convkey/f90c/79d5wrtyitwoi59zg.jpg)

FT813 de 5"
(http://www.mediafire.com/convkey/7c1c/g6ejyhbx4dgzabxzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 22, 2016, 04:25 pm
Nuevas gracias por tus comentarios.
Sería imposible tener estas pantallas y hacerla funcionar sin tu ayuda.

Ya tengo la soluciones a las pantallas FT800 con mcroSD y el audio.
Sobre el audio he realizado con un amplificador de bajo coste concretamente este modulo (http://www.banggood.com/2x3W-Mini-Digital-Power-Amplifier-Board-Class-D-Audio-Module-USB-DC-5V-p-929449.html), el filtro y sobre todo el buffer. Obtenía ruidos de niveles entre los 400~800 Hz y consulte las datasheet de FTDI y si que el audio sale de la pantalla en PWM entonces por ello se  usa éste para "limpiar" la señal. desguace una shield microsd de las que no me van y tenía  un SN74LV125A, el original es single (osea uno) y este ultimo lleva 4 buffer y obviamente solo es usar uno de ellos.

Lo he construido y va genial. así ha quedado;

(http://i.imgur.com/x7bkJup.jpg)


(http://i.imgur.com/2keDh6W.jpg)


Bueno y este es mi prototipo con la microSD, Audio y Arduino MEGA;

(http://i.imgur.com/EFHDDxC.jpg)

He probado la nueva pantalla FT811 con la librería Gameduino2 y me desilusioné, se veía la pantalla casi a la mitad con rayas y la otra con la imagen que puse en la SD. En un principio con la imagen era de 478x272, le puse una de 800x480 y lo mismo. Con la librería de FTDI pantalla negra... Total que la he vuelto a poner en la caja. Pero después de leer hoy tu comentario voy a probar.

A todo esto he pedido a Riverdi dos placas shield para Arduino, dos conectores FFC a 20 pines ya de paso y me ha parecido interesante al menos para las dos FT811, porque las FT800 una solucionada y la segunda irá por el mismo camino, es decir hacerlo todo a mano.

Había pensado por un momento usar las dos FT811 de posavasos...  Frustante fue probarlas. Nada voy a probar a ver si va bien.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 22, 2016, 06:05 pm
Bueno casi me da algo y no podía respirar jejejeje vaya sustos!

Con la librería FT813_lib la pantalla se me quedaba así;

(http://i.imgur.com/GsVDOQj.jpg)

entonces he modificado el fichero FT_Platforms.h donde la pantalla le tengo que poner esto;

Code: [Select]

/* Chip configuration specific macros */
//#define FT_800_ENABLE (1)
//#define FT_801_ENABLE (1)
//#define FT_810_ENABLE (1)
//#define FT_811_ENABLE (1)
#define FT_812_ENABLE (1)
//#define FT_813_ENABLE (1)


Es decir si le pongo como FT811 me hace las rayas, de esta forma como FT812 o FT813 me funciona todo, audio, táctil.
Con Gameduino2 me hace lo mismo que la primera captura, por lo tanto tiene que ser un problema de configuración ... lo voy a estudiar.

Gracias por los ejemplos de esta forma sé que la pantalla es funcional.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 23, 2016, 12:04 am
Acabo de probar con la librería de James y me da la misma caprtura.

Quote
Hay que explorar a fondo la actualización de esta librería, ya que de acuerdo con James, tiene soporte para las pantallas FT81X. Nos debería funcionar al 100% tanto en la FT813, como en tu flamante FT811.
Pues en mi pantalla no funciona. quizás sea un tema para reportar donde hay que saber los cambios que el realizó y como pone en GitHub tiene soporte y no es así.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 23, 2016, 04:24 am
Geniales esas fotos, me alegra saber que no solo yo veo que la pantalla está viva.

¿Podrías subir el sketch que usaste para cargar imagenes en la pantalla FT81X?, creo que el lector micro SD del shield no hace buen contacto con el arduino.

Por cierto, cuando tengas el shield de Riverdi, debes asegurarte que los pines del shield hagan contacto con los zócalos de tu arduino, trae pines algo disparejos y muy delgados; hay que ajustarlos manualmente.

PD: no entiendo a los de FTDI chip, siguen argumentando que solo sus placas FT900 son capaces de hacer funcionar las pantallas FT81X, y que no tienen planes para sacar una libreria para arduino.

¿Es en serio?, ustedes crearon estas pantallas!!!!
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 23, 2016, 11:37 am
¿Es en serio?, ustedes crearon estas pantallas!!!!
Opino como tu, son impresentables!!! por este camino no se anda. Tendrían que dar mas facilidad si es que desean comer el marcado pero esto los hace poco creíbles.

Tengo que decir que siempre les tuve manía a los chip driver FTDI, que las pantallas con estos son de lo mejor, sí, pero hay que dar soporte. No te preocupes, ya sabes que estoy aquí para averiguar estudiar y como no realizar lo que haga falta porque estas pantallas me tienen enganchado.  A la tarde edito el mensaje y pongo el código que he usado.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 23, 2016, 04:31 pm
Opino como tu, son impresentables!!! por este camino no se anda. Tendrían que dar mas facilidad si es que desean comer el marcado pero esto los hace poco creíbles.

Tengo que decir que siempre les tuve manía a los chip driver FTDI, que las pantallas con estos son de lo mejor, sí, pero hay que dar soporte. No te preocupes, ya sabes que estoy aquí para averiguar estudiar y como no realizar lo que haga falta porque estas pantallas me tienen enganchado.  A la tarde edito el mensaje y pongo el código que he usado.
Gracias estaré al pendiente del sketch para cargar jpg, y ¿cómo no?, cualquier progreso que consigas; para adicionarlos a la librería, que para eso está. Aún le faltan muchos puntos por cubrir.

Les he enviado la FT813_lib a los de FTDI,  a ver si la abren y ven que tiene dentro!!!. Soporte de Riverdi si que se aplicó y estuvo ajustando los registros de inicio para FT81X.

"Abrí el capó de la GD2", inserté los registros de inicio para FT80X que trae la FT813_lib y la  gameduino 2 activa sin problemas la pantalla FT801 que está en la mesa de pruebas.

Inserté los datos de registro para FT81X y simplemente veo una pantalla negra. Creo que el problema radica en separar los registros de inicio: RAM, REG, CMD, y funciones prediseñadas; de los registros para las pantallas FT80X, por allí debe haber alguno que no sirve en la serie 81X.

En caso extremo será necesario crear una librería GD2_FT81X, para facilitar las cosas.

PD: bajé la hoja de datos del FT81X, creo que habrá que meterse linea a linea y registro por registro, antes de pedir ayuda al creador de la librería del gameduino 2 y no llegar con las manos vacías.

http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT81x.pdf (http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT81x.pdf)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 23, 2016, 04:44 pm
He aquí el código;
Code: [Select]

#include <EEPROM.h>
#include <SPI.h>
#include <GD2.h>

#define PDNPin 8

void setup(){

  Serial.begin(115200);
  pinMode(PDNPin, OUTPUT);   // Código para realizar el POR por solftware pin PD
  digitalWrite(PDNPin, HIGH); 
  delay(20);
  digitalWrite(PDNPin, LOW);
  delay(20);
  digitalWrite(PDNPin, HIGH);
  delay(20);                         // Hasta fin
  GD.begin();
   GD.wr(REG_SWIZZLE, 0);
 //  GD.wr(REG_ROTATE, 4);   // INVERTIR LA PANTALLA

 
GD.cmd_loadimage(1, 0);
GD.load("image.jpg");
 
}

void loop()
{
   
 GD.Clear();
 
GD.Begin(BITMAPS);
GD.Vertex2ii(0, 0);

 GD.swap();
}



Te adjunto la imagen también.

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 23, 2016, 04:46 pm
Gracias, ¿la pantalla que usaste para cargar la imagen es la FT80X?

Si fué la FT811, ¿podrías subir tu librería para gameduino 2 modificada?.

Quizás me esté faltando alguna instrucción relacionada con el arduino Due.

PD: para subir archivos comprimidos, imagenes e incluso videos, creé una cuenta en mediafire allí he estado respaldando el avance de la librería para compartirlo.

Saludos
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 23, 2016, 05:38 pm
Aquí esta la librería GD2 adjunta que he usado.
La pantalla que usé es la FT811 la captura que salen las rayas en la parte izquierda, con la FT800 todo perfecto, no hay error.

A todo esto, la FT811 es de 18 bit y la que tu tienes la FT813 es de 24 he leído en esta DataSheet (http://www.ftdichip.com/Support/Documents/AppNotes/AN_390%20FT80x%20To%20FT81x%20Migration%20Guide.pdf) concretamente en la pagina 8 el apartado del reloj del chip en las FT81x es de 60MHz por defecto y en las FT80x es de 48MHz y esto en la librería GD2 lo he visto definido el reloj, pero solo para la FT80x, creo que es muy importante.

Y también, todas las pruebas las estoy realizando por Arduino MEGA, lo digo para referencia, ya que tengo ahora el Due en un proyecto de dos pantallas para GPS, y solo tengo una. Creo que voy a montar otro prototipo de las dos pantallas o no sé si mejor esperarme esta semana ya que los de Riverdi la tendría que recibir en unos 4-5 días ademas Polonia esta a unos 2.500 kilómetros y no esta en Asia.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 24, 2016, 09:06 pm
Gracias por la librería GD2 que usaste, voy a experimentar con un MEGA.

... no sé si mejor esperarme esta semana ya que los de Riverdi la tendría que recibir en unos 4-5 días ademas Polonia esta a unos 2.500 kilómetros y no esta en Asia.
Es como 1/4 de la paciencia que tuve que tener para que me llegara la pantalla!!!  (+/- 10,250 km hasta la mesa de trabajo XD).

En otro orden de ideas, he seguido experimentando con pantallas pequeñas, quiero sustituir el LCD de texto que tiene el depósito de agua de la refrigeración liquida de la PC. He pensado en un ST7735 o una pantalla oled a color.

Para ambos casos hay librerías de adafruit, creo que es posible extender a esas pantallas, el ejemplo de indicadores analógicos para ILI9341.

Indicadores analógicos en ST7735 de 1.8", SPI

Varios dispositivos como TFT´s, matrices de leds e incluso leds WS2812, pueden funcionar con la libreria GFX creada por adafruit. Basta con modificar la carga de librerias, las lineas de activación del setup y ajustar los gráficos a las medidas de cada pantalla.

Las pantallas ILI9341 tiene en general 320x240 px, el ST7735 tiene 160x128 px, la pantalla oled que tengo a mano tiene 96x64 px.

En el caso de la pantalla ST7735, las modificaciones son estas:

En el llamado de librerias y definición de colores:
Code: [Select]
#include <SPI.h>         
#include "Adafruit_GFX.h"
//#include "Adafruit_ILI9341.h"                             //ILI9341
//#define TFT_DC 9                                          //ILI9341
//#define TFT_CS 10                                         //ILI9341
//Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);  //ILI9341
#include <Adafruit_ST7735.h> // Hardware-specific library
#define cs   10
#define dc   8
#define rst  9 
Adafruit_ST7735 tft = Adafruit_ST7735(cs, dc, rst);

#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
//#define Personal tft.color565(20, 20, 20)    //ILI9341
//#define fondo tft.color565(0, 0, 0)          //ILI9341
#define Personal 0x2205
#define fondo   0x0000
#define YELLOW  0xFFE0 
#define WHITE   0xFFFF


En la función principal:
Code: [Select]
void Principal()
{
//  tft.setRotation(1);    //ILI9341
  tft.setRotation(3);
  tft.fillScreen(0x0000); 


En el setup:
Code: [Select]
void setup()
{
//   tft.begin();  //ILI9341
   tft.initR(INITR_BLACKTAB);   // initialize a ST7735S chip, black tab
   Principal();
}


Resultado:
(http://www.mediafire.com/convkey/dc3b/d4xc12gvlp6r55bzg.jpg)

ST7735: indicadores analógicos (http://www.mediafire.com/download/qsd7v3fqqx5woaf/UNO_ST7735_test_0_gauge_segmentado.rar)

Vídeo: ST7735_indicadores analógicos (https://www.youtube.com/watch?v=s6k08N1zQMM)

Vídeo: ILI9341_indicadores analógicos (https://www.youtube.com/watch?v=-0lzPJOCbY4)

Aunque el código funciona en el ST7735, pude medir el espacio en el que está el LCD del depósito, los pines del TFT no caben en el espacio disponible, pero el oled se ajusta perfectamente.

Queda por llevar el código a la pantalla oled. Luego de eso me aplicaré con la modificación del depósito de agua, instalación del FT801, instalación de los sensores NTC y de las rejillas de ventilación del domo, movidas por un servo controlado desde la pantalla táctil.

Quería usar el FT813, pero va a tener que estar un rato en la mesa de pruebas, instalaré el FT801

(http://www.mediafire.com/convkey/cb3b/shdll54q5rmgnl5zg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 24, 2016, 09:20 pm
Actualmente tengo instalado en el gabinete de la PC el FT843 (chip FT800) de 4D Systems con su ADAM. Está modificado para funcionar con la librería GD2. Lo usaré en otros proyectos, y prefiero instalar el FT801 que es mas resistente.

(http://www.mediafire.com/convkey/6746/8pcgmvalccdly24zg.jpg)

Vídeo: desplazamiento de objetos en el FT800 (https://www.youtube.com/watch?v=R4tUa0kyUhA)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 25, 2016, 09:17 am
Queda muy bien este ultimo vídeo. Podrías pasarme el código para probarlo? Gracias :)
En Riverdi compré 6 conectores de 10 pin´s;
(https://riverdi.com/wp-content/uploads/2016/04/ZIF0510DH-CF25-180x151.png)
El sábado hable con un amigo mio ingeniero de una empresa I+D y le comenté el problema de los cables del bus SPI de las pantallas FTDI, me comentó lo que tu escribiste concretamente la longitud y me añadió que también influye la impedancia del mismo, es decir la longitud crea unas determinadas capacidades a las entradas del chip en el cual produce un ruido y desacoplos, que unicamente se pueden eliminar realizando un buffer esto me hizo reflexionar. Desmonté ayer mi pantalla FT800 y he visto que  el bus SPI van directamente al chip FT800Q y he pensado realizarle un "plantacho" de las señales. No tengo problema ya que tengo los adaptadores de PCB y tengo varios SN74LV125A de los cuales van 4 buffer. Lo malo para lograr la mejor estabilidad del mismo, voy a tener que sacrificar un PCB virgen y realizarlo.

De paso como la placas PCB hacer de 100x160 podré realizar varias y el conector al control de Arduino le incluiré otra mas ya con la microSD.

A ver si lo tengo listo para el fin de semana.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 25, 2016, 10:19 am
Va el proyecto, hay muchas partes por optimizar, otras son solo experimentos. Espero no te resulte complicado entenderlo.

Desactivé la lectura de la hora del reloj DS3231, de lo contrario el programa se ralentiza demasiado por no estar conectado el 3231.

Probablemente te de falla en las librerías neopixel de adafruit, solo hay que descargarlas e instalarlas. También puedes eliminar/comentar las instrucciones que hagan el llamado.

No creo que te cause problemas la falta del analizador MSGEQ7, salvo que tendrás ruido en las bandas de cada canal y gráfica lineal. Los pines que usa son 2, 3 y A1.

Van las imágenes jpg que debes cargar en la microSD.

Avance del proyecto (http://www.mediafire.com/download/ch9j2dhgr0tkdzt/FT801_GD2_Desplazamiento_de_objetos_1.rar)

PD: para el arduino MEGA hay que adicionar esta linea
Code: [Select]
#include <EEPROM.h>
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 25, 2016, 04:31 pm
Bueno lo estado probando y me da error en todas las lineas que pone;
Code: [Select]
GD.swap();

El error que devuelve el IDE es;

Code: [Select]
Analizador.ino:54:14: error: macro "swap" requires 2 arguments, but only 1 given
Analizador.ino: In function 'void Analizador()':
Analizador.ino:54:15: error: statement cannot resolve address of overloaded function
macro "swap" requires 2 arguments, but only 1 given


He probado varios como 1.5.2, 1.6.3 1.6.2 y todos el mismo error.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 25, 2016, 08:10 pm
¿Podrías copiar todos los códigos de error que marca el IDE?

Estoy usando el IDE 1.6.3, el sketch compila sin problemas con las dos versiones de la librería para gameduino 2:
(http://www.mediafire.com/convkey/5c64/1l7ttvxv923hdp7zg.jpg)

El error relacionado con swap, tiene que ver con las librerias NeoMatrix de adafruit, ya que usaban también una instrucción llamada swap con dos argumentos. La versión actualizada de las librerías NeoMatrix no tiene conflictos con esa función del gameduino 2, me parece recordar que la eliminaron.

Sustituye la librería Adafruit_NeoMatrix por la versión reciente. Te paso la librería NeoMatrix actualizada (http://www.mediafire.com/download/qmeaan9yeyhafvg/Adafruit_NeoMatrix.rar)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 26, 2016, 10:06 am
Gracias.
He puesto la librería y me sigue dando error. Bien he comentado la librería Adafruit_GFX.h y no me daba problemas, entonces la que entraba en conflicto es esta anterior.

La he descargado y actualizado desde repositorio (https://github.com/adafruit/Adafruit-GFX-Library) y sin  problemas.
Acabo de realizar un test sin subir a la placa y como estoy en el trabajo no puedo probar, pero ya compila sin dar problemas. En cuanto llegue a casa y después de comer lo pruebo.

Ayer casi me vuelvo loco. a todo ello, voy comprendiendo como funciona los Tag en la librería Gameduino 2 con tus ejemplos. Ayer después de mucho dar vueltas y claro tirando del Book de la librería no encontré como ponerlos. He entado jugando con la librería de mathertel (https://github.com/mathertel) sobre Radio y se me colgaba constantemente y con tu código voy entendiendo de como se hace. A veces se necesita un empujón.

Total que no fue que perdiera la tarde, simplemente con el fracaso se aprende. Luego comento a la tarde.
Saludos!
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 28, 2016, 10:04 am
Quote
La instrucción PROTO en GD2

PROTO, definida en la linea siguiente:
Code: [Select]
Code: [Select]
#define PROTO                0

Permite controlar la disposición de la tabla de colores, orientación de pixeles y orientación del panel táctil de las pantallas FT80x. El gameduino 2 tiene una disposición "invertida", respecto al diseño original de FTDI, la razón posiblemente se deba al ángulo de visión de la pantalla del shield gameduino 2.

En la libreria nueva (GD2), esa linea ha sido suprimida, es importante rescatarla, ya que resulta mucho mas fácil manipular el cableado, con la orientación que tiene el gameduino 2, que con la disposición que tiene de fábrica el FT80x.
Hoy es Jueves. empiezo este mensaje con la cita de la pagina numero 3 donde arriba he puesto.
He llevado 3 días de peleas de lo GRANDE. Por esto lo he escrito en mayusculas.

La pantalla FT800CB que tengo, me presentaba inestabilidad, cuelgues he inclusive pantalla negra y la famosa pantalla de la muerte, concretamente esta;

(http://www.mediafire.com/convkey/1471/ujnp7pl45674jojzg.jpg)

Bueno, he realizado unas 8 u diez shields con diferentes lectores microSD y incluso con los adaptadores de SD y llegó a ser preocupante y recortar cables, cambiar y nada siempre cuelgues, rayas en pantalla y al final se congelaba el Arduino MEGA.

A sido muy frustrante. Use Arduino UNO y llegaba a ser mas estable pero al cabo de 3 minutos el mismo problema... Y ayer (toda la tarde)  puse los ejemplos de las librerías oficiales de FTDI y todo correcto. Llegue a pensar que Arduino MEGA no funcionaba bien con la pantalla, pero al principio si recuerdo que era correcto, entonces que pasa?

Como tenía otra pantalla igual, mismo problema y 2 pantallas no pueden hacer lo mismo... O bien que fueran defectuosas las 2, sin embargo como tengo otras 2 FT811 esto no ocurre. Iba por el buen camino. La variable PROTO como bien escibistes es para una definición del hardware y posiblemente como no uso la shield de gameduino esta me da problemas y es mas consultando el esquema de mi pantalla, suerte que el vendedor de la tienda donde lo compré tiene la DataSheet investigue que el pin GPIO0 no se usa y creo que tiene que ver sobre esa variable....

El hardware de mi pantalla adjunto es un breakout y por ello quizás no está todo definido, simplemente por ello su precio y sin duda para usuarios muy avanzados al menos en hardware no me pongo flores, porque aun así ha sido posiblemente en su 90% fruto de la casualidad, ésta a veces funciona.

La conclusión que he llegado, no solo el lector, cables pueden congelar, dejar de funcionar al menos mi pantalla, porque si con librería original funcionaba, entonces era la libraría Gameduino2 y que realice? borrar la linea que pone;

Code: [Select]
#define PROTO   0

En mi pantalla no es correcto. No digo que como se ha recomendado usarla, pero en mi caso me daba estos problemas. A todo esto ya he subido el código tuyo @TFTLCDCyg y funciona a la perfección.  las imágenes se muestran todas, sin ralentizaciones. Y rapidez

A todo esto, con una vieja shield de pantalla de 2.4 LCD, la cual tenía el LCD roto (ya me vino de China así) lo quité, desoldé los IC´s y recupere la microSD integrada en el circuito impreso, he añadido los conectores hembra y la shield, ha quedado de maravilla. A la tarde pongo unas capturas de como me ha quedado.


Añado mas información.

resulta que hay problemas con PROTO desde enlace foro Gameduino (http://gameduino2.proboards.com/thread/179/newbie-advice-15khz-output-touchsc) donde pongo la cita del sexto mensaje de James;



Quote
After from making the SPI hookup - if you change this line:

github.com/jamesbowman/gd2-lib/blob/master/GD2.cpp#L8

in the library so that PROTO is 0, and on the next line set STORAGE to 0, then it should work fine with 3rd party FT800 boards like this - apart from not having the SDcard/accelerometer function.
La cuestión es que si se usa la variable hay que desmarcar la opción de STORAGE a 0 es decir, que la pantalla no podrá usar el lector microSD... (Mala suerte)
Bien entonces, hay un dilema; elegir y mi caso es quitar la variable PROTO.


Espero que otros usuarios tengan en cuenta mi comentario para futuros problemas con esta pantalla.
Saludos :)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 28, 2016, 09:46 pm
Eso que llevas solo un par de semanas experimentando, y con un punto de partida... me tocó leer todo el foro del gameduino 2 y pasar muchas desveladas, los pantallazos azules ocurrían todos los días!!!.

1. En principio te sugiero que veas primero el pinout del shield del gameduino 2. Es muy importante que identifiques los pines que se deben conectar en tus pantallas FT800, ya que estamos en estos experimentos, hay que tener ese pinout todo el tiempo en mente.

2. El cableado del lector micro SD, debe ir conectado directamente en las lineas SPI de la pantalla.

3. El tema del PROTO 0/1, funciona para algunos casos (como lo has podido comprobar), de hecho la pantalla FT801 de riverdi funciona sin modificar la librería del gameduino 2, pero la FT843 de 4D Systems (un FT800), solo funciona con PROTO = 1, con PROTO = 0, la tabla de colores se invierte.

Este punto creo que se puede manejar, si primero se usan las librerias del gameduino 2 sin modificar nada. Si se detectan problemas, se debería considerar el uso de PROTO 0/1.

Finalmente: las pantallas FT811 que tienes, ¿con que librería las has hecho funcionar?

(Mi FT813 no responde con las librerías del gameduino 2, tendré que seguir revisando a detalle los comandos que tiene la FT813_lib. Por cierto, envié esa librería a soporte de FTDI, me respondieron este lunes que atenderán la petición. Específicamente les solicité que me den un ejemplo de como subir imagenes jpg desde un lector micro SD, ya que ni su manual de programación tiene instrucciones de como hacer tal cosa, un fallo bastante crítico: ustedes crearon esos chips!!!! -no les dije eso XD-).

FT813_lib: comando de rotación de pantalla

Los chips de la familia FT81X tienen una instrucción que permite definir la rotación de pantalla.

La instrucción es esta:
Code: [Select]
Ft_Gpu_CoCmd_SetRotate(phost,R);   
Donde R puede ser: 0, 1, 2 o 3

0 da la orientación de fábrica: x=800, y=480
(http://www.mediafire.com/convkey/9e43/f3xub9p7fmi43plzg.jpg)

1 da la orientación que tiene el gameduino 2: x=800, y=480
(http://www.mediafire.com/convkey/6d70/9yxa2vako5gpbxbzg.jpg)

Rotación 2 da la orientación: x=480, y=800
(http://www.mediafire.com/convkey/3a10/o3f06pa3md37isrzg.jpg)

Rotación 3 da la orientación: x=480, y=800
(http://www.mediafire.com/convkey/2ac0/ozhv68643e4w73yzg.jpg)

La he podido usar dentro del setup, de esta forma:
Code: [Select]
void setup()
{
  Serial.begin(9600);
  FT813begin();
   Ft_Gpu_CoCmd_SetRotate(phost,1);   
   SAMAPP_CoPro_Widget_Calibrate();
 
   MP(); 
}   


Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 30, 2016, 05:57 pm
Buenas.

Mi pantalla FT811 la he hecho funcionar con la librería que me pusiste la FT_813 y funciona correcta.
Hoy realizado cambios en la librería Gameduino2 y también funciona. Unicamente que tengo unos parpadeos si la imagen a mostrar es de 800x480 la tengo que poner inferior, por ejemplo a 750x 450 y entonces va bien.

He modificado no obstante la librería Gameduino2 para que funcionará en mi FT811, ya que le faltan las lineas principales para que esta funcioné. Te adjunto el fichero GD2.cpp donde;

linea 15 tiene;
Code: [Select]
#define BOARD         BOARD_FTDI_80x //    BOARD_GAMEDUINO23 // board, from above

lineas 30;
Code: [Select]
#define STORAGE       1                 // Want SD storage?
(esta es la que da problemas) Si la pongo a 0, no tengo SD pero es totalmente estable! es decir que hay algo en la libraría de Gameduino2 con la SD, esto es lo que voy a buscar en los próximos días.
Luego he añadido las lineas que van desde las lineas 292 hasta la 313


Code: [Select]
 // MODIFICADO POR MI by LIGHTCALAMAR
  GD.wr32(REG_HCYCLE, 1056);    // 900 //548
  GD.wr32(REG_HOFFSET, 46);     // 43
  GD.wr32(REG_HSIZE, 800);
  GD.wr32(REG_HSYNC0, 0);
  GD.wr32(REG_HSYNC1, 10);      // 41
  GD.wr32(REG_VCYCLE, 525);     // 500
  GD.wr32(REG_VOFFSET, 23);     // 12
  GD.wr32(REG_VSIZE, 480);
  GD.wr32(REG_VSYNC0, 0);
  GD.wr32(REG_VSYNC1, 10);
  GD.wr32(REG_DITHER, 0);        // 1
  GD.wr32(REG_CSPREAD, 0);       // 1
  // HASTA AQUI EL CODIGO SUPERIOR


Luego para volver a Gameduino2, solo hay que cambiar la linea 15 por;
Code: [Select]
#define BOARD          BOARD_GAMEDUINO23
Las lineas que he añadido es para que funcione la resolución de la pantalla y las he sacado del fichero ConfigFT813.h, las lineas son de las que van desde la 123 hasta la 137. No se como se comportará con otras instrucciones, al menos he probado unos botones por ejemplo;
Code: [Select]
GD.cmd_button(740, 420, 40, 30, 21, 0,  "Volver");    
Y se muestra el botón en la posición. Tendré que hacer mas pruebas.
Lo he probado con tu código de desplazamientos y te dejo el enlace de un mini vídeo, ya que es muy difícil realizarlo y a la vez con la pantalla táctil (ojala fueran estos los problemas!!!) .Todavía no me han llegado las placas Riverdi y estoy entonces seriamente pensando que quizás sea problema de ruidos con mi microSD. Lo esperaba esta semana pero no ha sido así. A ver si en la semana que viene las tengo y puedo experimentar mas.
Y antes que se me olvide también hay que jugar con la posición de la pantalla, en mi caso de tu código he tenido que usar en el setup;
Code: [Select]
GD.wr(REG_ROTATE, 1);

Vídeo TEST pantalla FT811 con libraría Gameduino2 (https://youtu.be/530RstQ_ueY)
como observarás en el vídeo, es ligeramente pequeño las dimensiones de donde has creado botones etc...
Voy hacer un paréntesis, porque no quiero lastimar las pantallas. Me refiero al cable FFC ya que son delicados y de tanto sacar y meter... a ver si viene las shields de Riverdi como te he comentado y  tengo dos prototipos para probar.
No obstante dejaré de momento puesta la pantalla FT811 y así ir comentando lo que vaya saliendo y/o modificar.
Saludos!
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 07:22 am
Vaya veo en puerta otras desveladas !!!, menudo gran trabajo que te has mandado con esas FT811.

He sustituído el archivo que compartiste GD2.ccp en la libreria del gameduino 2 y me han saltado varios errores. Por favor podrías subir la libreria completa que estas usando para el gameduino 2, quizás falten algunas definiciones que ajustaste en el archivo GD2.h.

PD: gracias por el soporte, yo no me he metido a fondo en la construcción de librerías, creo que mi FT813 no se deja con el shield de Riverdi, voy a tener que armar una interface hilo por hilo.

Indícame como has hecho tu cableado para seguirte los pasos y testear de nuevo la libreria que has modificado.

Por cierto, el FT801 funciona muy bien con el shield de Riverdi para arduino y las librerias del gameduino 2. El FT813 tampoco presenta errores con el shield de Riverdi, excepto por la libreria del gameduino, que se resiste con ella y no da señales de vida.

El que necesita consejos con la FT813 + gameduino 2_lib ahora soy yo jejejeje.

Por favor detalla como has conectado tu FT811, que seguiré las instrucciones al pie de la letra
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 12:33 pm
Como dije hoy tocaba desvelada, esa GD2.ccp que subiste me llevó a estos extremos.

Revisé detenidamente los cambios que hiciste solo que por falta de tiempo solo fuí tomando piezas del rompecabezas, ese ccp que subiste, me permitió ver por donde andábamos.

Rearmé toda la librería que construíste, y debo agradecerte por dedicarle tiempo y sobre todo por meterle mano a la parte ruda: los registros del FT81X. Acertaste en los ajustes.

De hecho el punto clave es configurar la librería como si estuviera conectado un gameduino 2 y no una FT80X, como había hecho yo hasta ahora; y pues, siempre fallaba el FT813. Me di cuenta por error al dejar seteado 1 en lugar de 0, en esta linea:
Code: [Select]
#define BOARD         1 //    BOARD_GAMEDUINO23 // board, from above

Desconecté todo y conecté hilo por hilo, primero el FT801 y luego sustituí la pantalla por la FT813, luego solo ajusté algunos de los parámetros de registro que subiste a la librería para hacerlos coincidir con el FT813. Adjunto la librería con algunos ejemplos que ayudarán a testear la SD card.

Debería llamarse GD3 !!!!, bien lo vale: descarga de la libreria GD2 modificada por ligthcalamar para la familia FT81X (http://www.mediafire.com/download/5qgb11fx96r85k2/GD2.rar)

Incluye un test para verificar el funcionamiento de la pantalla táctil, funciona perfectamente para la pantalla capacitiva del FT813 y sus 24 bits. Solo falta ajustar la velocidad de reloj y posiblemente ajustar algunos detalles.

De nuevo mil gracias lightcalamar!, pensé que tendría que lidiar con la librería de FTDI otra vez!!!!.









Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 31, 2016, 12:39 pm
Hace años que me dedico a mi eslogan,
"Sí se vende es porque funciona..." Yo todo lo que compro lo hago funcionar si o si, así de claro, me constará mas o menos pero al final funciona. En la red no me encontraras como mi nick actual y ademas cuando realizaba trabajos para Team´s por el típico que soy el amigo de un amigo y como vengo del Código Abierto (Linux) en su día todo se compartía sin animo de lucro.
En estos tiempos que corren ya no se hace, hay muchos interés económicos, sin embargo yo tal y como soy, soy una persona en estado de extinción. recuerdo las primeras Riva TNT1 gráficas de nVidia que no funcionaban en Linux... tienen mi sello jejejejeje (el nick que usaba en su día) pues esta fue la primera que cayó... Y todo por hobby.
Algunos me reconocen por la forma de escribir, nunca he usado otro como el propio que tengo y esto te delata, hasta el punto que algunos me han reconocido. Cambiando de tema.

Te adjunto la librería que ahora mismo funciona en mi MEGA y la shield te pongo unas capturas. Es de una antigua MCUFriends.com de 2.4 que solo tiene a día de hoy el lector microSD como dije en un mensaje anterior le quite los buffers y el LCD.

En hardware hay un tema que nadie ha escrito y tampoco nadie lo hace. Cuando se compra un hardware siempre hay que hacerlo en par, es decir comprar 2, es muy importante, de esta forma siempre tendrás la solución de que nunca dudaras de lo efectivo que puede ser, un ejemplo es en caso de duda poner otra pantalla, otro cable etc...

En esta aventura de estas pantallas tengo este material;

Soy consciente que esto no todo el mundo lo puede hacer, este desembolse económico, pero créeme no existe otra forma de tener la satisfacción del correcto funcionamiento. A la tarde te preparo un zip con los esquemas y capturas de lo que me pides. Me gustaría que me enviases la DataSheet de tu pantalla LCD(si es que lo tienes) por lo demas no hay problema y de lo contrario realizarme unas capturas de buena resolución, mi correo es mi nick con gmail.com (se intuye no?)
He comprobado que compila en IDE 1.6.3 y yo uso 1.6.5-r2 perfecto.
(http://i.imgur.com/yHI8Q0y.jpg)
Esta captura es de un ejemplo tuyo claro sin modificar, por ello sale "pequeño" en la FT811 jejeje.
A todo esto, yo soy muy negado en escribir ingles(leerlo si, pero escribir...) porque no escribir en el foro de James y exponerle este problema?, me da igual que sea tu el autor del tema, no tengo problemas como escribí al inicio.
Saludos!



Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 12:47 pm
Modifiqué el mensaje al mismo tiempo que tu escribías.

He conseguido hacer funcionar los ajustes que hiciste, y aportando algun granillo de arena en el costal, ya tengo funcionando el FT813 con la GD2.

Inserté algunos ejemplos para verificar carga de assets, imágenes y táctil. Y es posible usar el shield de Riverdi para arduino. Funciona impecablemente en el Due, sin ajustar nada.

(http://www.mediafire.com/convkey/56e8/2cyn6b7t0alj7hhzg.jpg)

(http://www.mediafire.com/convkey/7f8d/8xfory22y0r83cozg.jpg)

PD: para eso son los ejemplos, para adaptarlos y usarlos, ese ejemplo que bajaste le faltaban algunos ajustes de tuercas con el tema de los tags; espero que quede mas claro en el test que incluí en la librería.

Luego de dormir unas horas, voy a rediseñar el test de imágenes para verificar la estabilidad del lector microSD, creo será bueno meterlo en los ejemplos.

Respecto a la inversión, en estos casos hay que ahorrar un poco más, y esperar pacientemente los eternos lapsos que duran los envíos internacionales, no queda de otra.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 31, 2016, 12:54 pm
Ok. Muy bien, esa rubia la conozco yo jejeje. entonces no entiendo del porque James puso que funcionaba en las FT8xx, supongo que te habrás fijado que para la shield EVITA ai están definidos los registros.
Es verdad nos hemos pisado los mensajes.

Me das una alegria que funcionen en Riverdi. A comer uñas algunos días todavía me toca.
Buen camino llevamos entonces las pantallas!
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 01:11 pm
Pienso que James está inmerso en el tema del diseño del GD3, pero con las prestaciones que tuvo el gameduino 1, estaba diseñado para trabajar con monitores VGA, y me imagino que quiere sacar el máximo potencial al FT81X para hacerlo funcionar con monitores a altas resoluciones.

Él siempre comentó que la librería GD2 esta en fase experimental, estaría bien que le compartieras los progresos que hiciste, en una de esas, termina por dejarla a punto con los ajustes que le deben hacer falta.

Por cierto este es el cableado mínimo con el que funcionó el FT813 5" uxtouch de Riverdi, conectado directamente al arduino Due:

Code: [Select]
Vcc = 3V3, Gnd, MOSI (11), MISO (12), SCK (13), CS (10), SD_CS (5), BlGND (GND), BLVdd (3V3)
INT, y PD sin conectar


El shield de riverdi tiene trazadas las conexiones del lector micro SD a las mismas lineas SPI de la pantalla, así que para armar uno externo hay que respetar ese conexionado.


PD: esa rubia me inspiró en estas horas de insomnio jejejeje.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 31, 2016, 01:24 pm
estaría bien que le comentaras los progresos que hiciste, en una de esas, termina por dejarla a punto con los ajustes que le deben hacer falta.
PD: esa rubia me inspiró en estas horas de insomnio jejejeje.
Realízalo tu @TFTLCDCyg que mi ingles es de maquina y no me entendería. No sufras, como si tu lo hubieses echo tu mismo , en serio no tengo problemas sobre esto. Tambien la rubia me inspiró en horas de frustración....
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 31, 2016, 06:53 pm
Debería llamarse GD3 !!!!, bien lo vale: descarga de la libreria GD2 modificada por ligthcalamar para la familia FT81X (http://www.mediafire.com/download/5qgb11fx96r85k2/GD2.rar)
Comprobada, pero me presenta pantalla negra. Claro supongo que es para Arduino DUE. :) :) :)

Edito.
====
Con los otros ejemplos correcto. sin embargo a los 30 segundos o mas se me cuelga el Arduino MEGA. Creo que estas pantallas FT811, necesitan una MCU de mas potencia. A ver si espabilan los de Riverdi porque, por lo visto tan solo tendría que realizar unas simples conexiones con Arduino DUE.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 08:29 pm
¿Que longitud total tienen las lineas SPI?. Recuerda que el rango va de 14 a 20 cms.

Cuando hice experimentos con el MEGA y el shield gameduino 2, encontré que para el MEGA se deben puentear las lineas SPI, para que el porteo que hace la librería GD2 funcione de forma correcta:
Code: [Select]
MISO MEGA - MISO UNO
MOSI MEGA - MOSI UNO
SCK MEGA - SCK UNO


En el Due no es necesario hacer este cableado.

(http://www.mediafire.com/convkey/18f5/wl1y73ud56gufnqzg.jpg)

En efecto el consumo de energía que conduce la libreria GD2 lleva al limite al MCU, sin embargo el Due ni se despeina. El shield de Riverdi tiene algunos componentes extra para manejar esa corriente, que es mucho mayor en el FT813 ya que su liminosidad es la mayor de todas las pantallas, para complicar las cosas la FT813 requiere de dos lineas de alimentación 3v3 para los leds de retroiluminación.

La libreria de FTDI es mucho mas eficiente con el manejo energético, la linea de conexión puede extenderse hasta a dos cables planos en serie, mientras que la del gameduino 2 máximo llega a 1.

FT813_lib
(http://www.mediafire.com/convkey/7c1c/g6ejyhbx4dgzabxzg.jpg)

GD2_lib
(http://www.mediafire.com/convkey/56e8/2cyn6b7t0alj7hhzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 08:43 pm
Veo que no solo es ajustar de forma general los valores de registro para el FT81X. Debe hecerse por cada tipo de pantalla: FT810, FT811, FT812 y FT813.

Y también el cableado, en el FT813
Code: [Select]
CS o GPU_sel va al pin 10
SD CS  va al pin 5


En tu FT811 tienes esta asignación de pines:
Code: [Select]
CS al pin 9
SD_CS al pin 10


En el archivo wiring.h tienes este encabezado:

Code: [Select]
#ifndef CS
#define CS 9  // ANTES PIN 10
#endif

class GDTransport {
private:
  byte model;
public:
  void ios() {
    pinMode(CS, OUTPUT);
    digitalWrite(CS, HIGH);
    pinMode(9, OUTPUT);
    digitalWrite(9, HIGH);

 
Estas lineas deben coincidir con la forma en que tienes conectado CS y SD_CS. Las dos primeras funcionan para al CS, las dos restantes para SD_CS

Code: [Select]
    pinMode(CS, OUTPUT);    //CS pin, en tu caso es 9, no debes cambiar nada aquí
    digitalWrite(CS, HIGH);    //CS pin, en tu caso es 9, no debes cambiar nada aquí
    pinMode(9, OUTPUT);      //Este debe corresponder al pin SD_CS, en lugar de 9 debes poner 10
    digitalWrite(9, HIGH);     //Este debe corresponder al pin SD_CS, en lugar de 9 debes poner 10


Quizás allí es donde se está afectando el desempeño de tu lector microSD.

Prueba extrayendo los ejemplos de la versión que subí y aplícalos con  los ajustes que encontraste para tu pantalla.

PD: de hecho la versión que subiste deja a la FT813 aventando pantallas negras, pensé que me había afectado no dormir y por eso llegué a ver un Hello world luego de mover algunos parámetros de la librería o que había soñado ver a la rubia en pantalla XD.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 31, 2016, 09:49 pm
Intenta con esta versión ajustada para MEGA, y los parámetros que yo usaría si tuviera una FT811 en la mesa de pruebas:

GD3 para FT811/MEGA (http://www.mediafire.com/download/tlxbxghnzpa9yr9/GD2_Modificada+para+el+FT811+en+MEGA.rar)
(está ajustada para los pines 51, 52 y 53)


PD: una vez mas, para usar la libreria del gameduino 2 en el MEGA, recuerda puentear los pines SPI del MEGA, pero usa en la librería la configuración para Due/UNO.

Recuerdo que James quería que el shield gameduino 2 funcionara directamente en el arduino Due; es por eso que decidió portear las lineas SPI, tal como están el el arduino UNO.

En el MEGA necesariamente hay que conectar los cables del puerto SPI a los pines 11, 12 y 13, sin esas lineas, en el arduino MEGA es imposible portear las lineas SPI, al diseño SPI del arduino UNO.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 01, 2016, 07:06 am
Revisé el manejo de varias instrucciones y comandos. Texto, numeros, y widgets funcionan bien.

Las instrucciones para dibujar primitivas, aun tiene algún detalle:

En GD2.h
Code: [Select]
#define VERTEX2II(x, y, handle, cell) \
        ((2UL << 30) | (((x) & 511UL) << 21) | (((y) & 511UL) << 12) | (((handle) & 31) << 7) | (((cell) & 127) << 0))



En GD2.ccp

Code: [Select]
void GDClass::Vertex2f(int16_t x, int16_t y) {
  // x = int(16 * x);
  // y = int(16 * y);
  cI((1UL << 30) | ((x & 32767L) << 15) | ((y & 32767L) << 0));
}
void GDClass::Vertex2ii(uint16_t x, uint16_t y, byte handle, byte cell) {
  // cI((2UL << 30) | ((x & 511L) << 21) | ((y & 511L) << 12) | ((handle & 31L) << 7) | ((cell & 127L) << 0));
  union {
    uint32_t c;
    uint8_t b[4];
  };
  b[0] = cell | ((handle & 1) << 7);
  b[1] = (handle >> 1) | (y << 4);
  b[2] = (y >> 4) | (x << 5);
  b[3] = (2 << 6) | (x >> 3);
  cI(c);
}
void GDClass::VertexFormat(byte frac) {
  cI((39UL << 24) | (((frac) & 7) << 0));


Las instrucciones que permiten dibujar en pantalla son vertex2f y vertex2ii, tal como están ahora, solo permiten dibujar dentro de una región de 511x480 px, en lugar de los 800x480.

Intenté modificarlas pero están en chino, los pantallazos azules saltan por todos lados, no las entiendo.

Envíe una consulta a James, a ver si puede orientarnos como corregir ese detalle.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Aug 01, 2016, 04:36 pm
Ooooh !! muchas gracias, hay trabajo para unas buenas tardes.

Me acaba de llegar el paquete de Riverdi, todo correcto. Estoy estudiando del posible mal funcionamiento de mi pantalla. Aunque lo intuí creo que se va confirmando. He descargado la  DataSheet de la Shield Arduino (http://riverdi.com/datasheet/ardurino-shield)
Y ahora lo veo mas claro. La cuestión que se usa unos buffer´s donde el BUS SPI va a 3,3 voltios vpp (voltaje pico a pico).

Esta mañana en el trabajo he determinado este valor y me da 5Vpp en mi actual configuración, lo mismo el BUS va saturado en amplitud y zas... deja de funcionar. No lo tengo muy claro todavía pero apostaría de poner la mano en el fuego y no me quemaría. Voy a probar la shield y cuento, tengo que adaptar el conector de 20 pin´s a mi pantalla que tiene 10. Donde realmente la shield de Riverdi solo usa 10 pin en realidad, algunos no son conectados y doblan el pin para el consumo del Backlight. Otra cosa con respecto al BUS SPI, ya desde mi pantalla sale tambien a 3,3V y la transducción tiene que llegar a 3,3V y no 5V como lo tengo en este momento. Ummmmm, lo mismo funciona...



Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 01, 2016, 09:34 pm
También tienes trabajo para rato para pasar todo al shield de Riverdi. Por cierto, incluye un amplificador para speaker; un jumper para seleccionar el voltaje de alimentación de los leds de retroiluminación, 3V3 es para Due y 5V para MEGA/UNO. Lo mejor es que incluye un lector microSD 100% compatible con las librerías GD2.

Sobre todo funciona perfectamente con el Due,  a pesar de que los de Riverdi no me lo confirmaron aun!!!, no sé si con el MEGA se tenga que conectar las lineas SPI, será cosa de experimentar.

¿Es necesario que batalles con el MEGA?, las pantallas FT8XX son de 3V3, el Due opera con logica de 3V3; pero entiendo que impresiona demasiado hacer funcionar MCU de tan bajos MHz, impulsando pantallas como las FT.

Instrucción vertex2f

nomenclatura: Vertex2F(x*16, y*16)
Campo de pixeles: positivo y negativo

Seguí haciendo pruebas con las instrucciones de dibujo de primitivas. Afortunadamente la instrucción vertex2f funciona dentro de los 800x480 pixeles que tiene la pantalla, solo hay que ajustar dos parámetros de registro en el archivo GD2.ccp, para que los bordes de la pantalla queden dentro de las dimensiones máximas del campo de pixeles

Para el FT813 de Riverdi y sus 800x480 pixeles:
Code: [Select]
GD.wr32(REG_HOFFSET, 47);     // 43
GD.wr32(REG_VOFFSET, 23);     // 12


vertex2f mejora la calidad de los trazos, ya que puede dibujar fracciones de pixel de hasta 1/16. Permite dibujar primitivas en zonas que tienen "coordenadas negativas", es decir, ubicadas antes de la coordenadas (0,0), (0,x) y (x,0). También permite dibujar imagenes jpg individuales, que no forman parte de un arreglo o asset.

Video: capacidades de la instrucción vertex2f en el FT800 (https://www.youtube.com/watch?v=St9rRNBZ6ME)

Instrucción vertex2ii

nomenclatura: Vertex2ii(x, y, cell)
Campo de pixeles: positivo, restringido a 511 x 511 pixeles

Vertex2ii, dibuja pixeles "enteros", permite dibujar primitivas e imagenes jpg o png. En la libreria GD2, gracias a esta instrucción se puede dibujar cada una de las imagenes asociadas a un asset o grupo de imagenes.

De acuerdo con el manual de programación del FT81X, el espacio de trabajo de esta instrucción está acotado dentro de una región de 511 x 511 pixeles, cuyas fronteras son: (0,0), (0,x) y (x,0), es decir solo pixeles positivos, creo que en este aspecto no hay mucho por hacer o corregir.

He modificado el test de carga de imágenes, incluyendo algunas primitivas.
FT81X: test para verificar estabilidad  (http://www.mediafire.com/download/p7fyk87w8aejp7c/FT813_test_iconos_primitivas_1.rar)

Hay una función creada por James, que permite dibujar polígonos, se encuentra al final de archivo GD2.h. Originalmente este es su diseño:

Code: [Select]
class Poly {
    int x0, y0, x1, y1;
    int x[8], y[8];
    byte n;
    void restart() {
      n = 0;
      x0 = 16 * 480;
      x1 = 0;
      y0 = 16 * 272;
      y1 = 0;
    }
    void perim() {
      for (byte i = 0; i < n; i++)
        GD.Vertex2f(x[i], y[i]);
      GD.Vertex2f(x[0], y[0]);
    }
  public:
    void begin() {
      restart();

      GD.ColorMask(0,0,0,0);
      GD.StencilOp(KEEP, INVERT);
      GD.StencilFunc(ALWAYS, 255, 255);
    }
    void v(int _x, int _y) {
      x0 = min(x0, _x >> 4);
      x1 = max(x1, _x >> 4);
      y0 = min(y0, _y >> 4);
      y1 = max(y1, _y >> 4);
      x[n] = _x;
      y[n] = _y;
      n++;
    }
    void paint() {
      x0 = max(0, x0);
      y0 = max(0, y0);
      x1 = min(16 * 480, x1);
      y1 = min(16 * 272, y1);
      GD.ScissorXY(x0, y0);
      GD.ScissorSize(x1 - x0 + 1, y1 - y0 + 1);
      GD.Begin(EDGE_STRIP_B);
      perim();
    }
    void finish() {
      GD.ColorMask(1,1,1,1);
      GD.StencilFunc(EQUAL, 255, 255);

      GD.Begin(EDGE_STRIP_B);
      GD.Vertex2ii(0, 0);
      GD.Vertex2ii(511, 0);
    }
    void draw() {
      paint();
      finish();
    }
    void outline() {
      GD.Begin(LINE_STRIP);
      perim();
    }
};


Lo modifiqué para que se ajuste al campo 800x480. Además sustituí las instrucciones vertex2ii, por su equivalente en vertex2ff, para evitar fallos después de los 511 pixeles que permite vertex2ii.

Code: [Select]
class Poly {
    int x0, y0, x1, y1;
    int x[8], y[8];
    byte n;
    void restart() {
      n = 0;
      x0 = 16 * 800;
      x1 = 0;
      y0 = 16 * 480;
      y1 = 0;
    }
    void perim() {
      for (byte i = 0; i < n; i++)
        GD.Vertex2f(x[i], y[i]);
      GD.Vertex2f(x[0], y[0]);
    }
  public:
    void begin() {
      restart();

      GD.ColorMask(0,0,0,0);
      GD.StencilOp(KEEP, INVERT);
      GD.StencilFunc(ALWAYS, 255, 255);
    }
    void v(int _x, int _y) {
      x0 = min(x0, _x >> 4);
      x1 = max(x1, _x >> 4);
      y0 = min(y0, _y >> 4);
      y1 = max(y1, _y >> 4);
      x[n] = _x;
      y[n] = _y;
      n++;
    }
    void paint() {
      x0 = max(0, x0);
      y0 = max(0, y0);
      x1 = min(16 * 800, x1);
      y1 = min(16 * 480, y1);
      GD.ScissorXY(x0, y0);
      GD.ScissorSize(x1 - x0 + 1, y1 - y0 + 1);
      GD.Begin(EDGE_STRIP_B);
      perim();
    }
    void finish() {
      GD.ColorMask(1,1,1,1);
      GD.StencilFunc(EQUAL, 255, 255);

      GD.Begin(EDGE_STRIP_B);
      GD.Vertex2f(0*16, 0*16);
      GD.Vertex2f(800*16, 0*16);
    }
    void draw() {
      paint();
      finish();
    }
    void outline() {
      GD.Begin(LINE_STRIP);
      perim();
    }
};


Llevé el proyecto al siguiente nivel: usar la pantalla FT813 con el break out de 20 pines y el lector microSD externo... parece que vuelve a superar la prueba, el shield casero funciona para ambas familias: FT80X y FT81X, solo hay que cambiar la librería de control.
(http://www.mediafire.com/convkey/89bc/hkao72cyw8yrpaszg.jpg)

(http://www.mediafire.com/convkey/93bb/ooyvsen24u39k2bzg.jpg)
Dejaré la prueba unas horas para ver el comportamiento de la pantalla, esperemos que no haya mas sorpresas.

ligthcalamar nuevamente gracias por el soporte, deberías trabajar con FTDI o con James jejejejeje, aun sigo esperando respuesta de FTDI, de Riverdi y de James...

PD:
Feliz: pensé que el FT813 sería el pisapapeles más caro de este año!!!.
Seguimos progresando...
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Aug 02, 2016, 12:49 am
Buenas noches pero de las BUENAS.
No suelo escribir en MAYÚSCULAS pero esta vez lo he realizado porque, al fin la técnica triunfa sobre mi propia mediocridad, y lo reconozco, es para darme un palo en la cabeza y no ponerme medallas.

Llegó las shields de Riverdi, a  30 minutos de escribir mi ultimo mensaje me puse en ello. La frustración fue de lo mas infinita. MISMO PROBLEMA... no se lo que se siente a 36 grados de calor en España con una pantalla que se cuelga, se queda negra y realiza desvanecimiento, pero si que empezé a sudar, los sudores de la muerte, hasta casi, me da un mareo y todo... Esto a las 16H35 mas o menos...

Lo primero que realice fue imprimir en PAPEL la DataSheet de Riverdi, la DataSheet de FTDI del chip FT81xx y faltó papel, como siempre... Una vez conseguido, puesto que tuve que ir a por tinta negra.. (otra mas, para mala suerte o (*)) encepe a estudiar el HARDWARE de la pantalla... Si me dije si al principio me funcionaba correcto en la librería FTDI que mi**da esta pasando?

He recortado cables, vamos hasta 3,5 cm o 35mm y LO MISMO.  Probando en Arduino UNO, DUE, otras 3 Arduino MEGA, same problem? (eso dicen los ingleses no?)  mas sudor, pero ya tuved que ponerme dos toallas al lado. Si creedme, para rodar una película.
Recordé este mensaje tuyo;


Quote
Eso que llevas solo un par de semanas experimentando, y con un punto de partida... me tocó leer todo el foro del gameduino 2 y pasar muchas desveladas, los pantallazos azules ocurrían todos los días!!!.

1. En principio te sugiero que veas primero el pinout del shield del gameduino 2. Es muy importante que identifiques los pines que se deben conectar en tus pantallas FT800, ya que estamos en estos experimentos, hay que tener ese pinout todo el tiempo en mente.
Y después de toda la tarde, experimentado, decidí quitar todos los cables a la sield de Riverdi, cojer los típicos cables de protoboards de toda la vida de Arduino (22 cm) , cablear todos los pin´s, los 10 que tiene mi pantalla donde bien me dijiste que los pin PD e INT no se usaban, sin embargo en mi pantalla tuve que batallar con el POR (Power On Reset ) sin embargo no le he prestado atención al pin INT que si que lo usa Riverdi...Este va directamente a GND.  La sields lo usa y va conectado a GND, es tu caso, @TFTLCDCyg  lo has comentado que no se usa, vale no se USA porque desde la propia pantalla tuya la FT813 ya la deriva a GND, es así?

Mi problema a sido de no poner el pin llamado INT a GND,  en la librería de FTDI después he investigado que se realiza un;
Code: [Select]

pinMode(PIN_INT, LOW);


Claro es una salida hacía donde? en la DataSheet de FTDI, es lograr un desvanecimiento, y digo yo para que? con esto se cuelga la pantalla, o no? pero averiguarlo, si ya es tardío la librería  FTDI yo al menos no me meto en ella, jejeje

Lo normal es que realice una solución llamada "fuerza bruta" que consiste en realizar el POR con una RC directamente al pin PD y poner  a GND el pin INT,, dos cables menos, entonces para que? ya porque los de FTDI así son de retorcidos, con lo sencillo que es realizar el hardware, por que complicar pines para manejar por software, mi no entienda... (eso diría un Alemán)

Es por esto que te pedí unos mensajes atrás de  tu DataSheet de tu LCD.

Te lo pido como favor, aunque ya lo tenga solucionado, quisiera disponer de tu LCD como DataSheet es posible? Si la compraste en Riverdi, dime el modelo.  
Total que a las 22H15 aproximadamente funcionó cualquier ejemplo que subiste a la librería sin problemas, es es solo un comienzo...

Sobre James, si es muy interesante, y nunca dejaré de decirte que tu me has ayudado, y mi ayuda si te  ha servido, esto es porque hay implicación.

P.S. He realizado capturas y mañana por  editaré este mensaje para  que veas como ahora tengo el "banco del experimento"
P.S.2. Ya tengo proyecto RadioFM with RDS 4.0 With FT81x  (en breve)
P.S.3  Estoy seriamente planteándome comprar algunas mas pantallas que he realizado, ya teniéndolas a punto. Lo digo por el precio y que se agoten...
P.S.4 No me cansaré de escribir que estas pantallas son impresionantes!!!!
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 02, 2016, 01:45 am
La pantalla FT813 de Riverdi es esta: RVT50UQFNWc00 (https://riverdi.com/product/rvt50uqfnwc0x/), al final está el datasheet.

La pantalla FT801 de Riverdi es esta:RVT43ULFNWC0X (https://riverdi.com/product/rvt43ulfnwc0x/), al final está la hoja de datos.

También tengo un FT843+ADAM de 4D Systems: datasheet del FT843 (http://www.4dsystems.com.au/productpages/4DLCD-FT843/downloads/FT843-4.3-Display_datasheet_R_1_2.pdf)
Datasheet del ADAM para el FT843 (http://www.4dsystems.com.au/productpages/4Display-Shield-FT843/downloads/4Display-Shield-FT843-ADAM_datasheet_R_1_0.pdf)

La otra pantalla es el shield gameduino2: datasheet (http://excamera.com/files/Gameduino2hw.zip)

Dado que quieres usar la librería para el gameduino 2, te sugiero una vez mas, leer como se conecta, yo también me topado con tardes en las que ninguna pantalla da señales de vida, reviso el pinout del gameduino 2 y como que me vuelvo a concentrar

Acá están el FT813 (arriba) y el FT801 (abajo), mostrando parte del sketch del proyecto:
(http://www.mediafire.com/convkey/7350/h4mbdqkgsblchqpzg.jpg)
Las dimensiones del FT813, muestran cuanto espacio adicional se puede usar, en comparación con el campo de 480x272 pixeles de la FT801!!!

Para la libreria FTDI si es importante conectar PD e INT, sin embargo para GD2, en las tres pantallas FT8XX que he podido conectar, no ha sido necesario usar PD ni INT.Acá están el FT801
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Aug 08, 2016, 11:27 pm
Buenas noches.

Estoy preparando un regalito a estas pantallas, al menos en las mías que compré pero necesito una ayuda urgente en un código... Llevo unos días estudiando el tema de los cables, y creo que ya lo tengo dominado.

@TFTLCDCyg necesito de tu gran ayuda, me pongas un código que me realice unas diapositivas, es decir, que cada 2 o 3 segundos me nuestre una imagen que recoge de la microSD, he realizado hoy algunos pero no me funcionan y se que tu tienes dominado la librería Gameduino2. Es un favor que te pido.

Estoy de vacaciones y no quiero invertir el código para desarrollar anterior en todas mis vacaciones, por decirte algo he realizado esto y solo me presenta una imagen;
Code: [Select]

    GD.cmd_loadimage(0, 0);
    GD.load("tesla.jpg");

     delay(2000);
    
     GD.cmd_loadimage(0, 0);
     GD.load("selfie.jpg");
      


En el loop solo me sale la primera imagen y la segunda no sale. No se si estudiar primero los comandos de Gameduino2 y pasarme todas las vacaciones con esto.

El realizar esta prueba, solamente es saber si se cuelga o se queda en loop continuo el AVR del MEGA.

Saludos.
EDITO  el mensaje.
===============

Me acabo de dar cuenta que todas las imágenes han de tener la misma resolución (en mi caso 480x272) y ahora funciona con este código en el loop; (creo que era un problema de resolución de las diferentes imágenes y por ello o no salen o pantalla negra, supongo que hay que poner otro parámetro a la hora de poner otra imagen diferente, con el código de abajo todas tienes la misma resolución, es decir 480x272)
Code: [Select]

void loop()
{
  
    GD.Clear();
 
    GD.Begin(BITMAPS);
    GD.Vertex2ii(0, 0);

    GD.cmd_loadimage(0, 0);
    GD.load("radio3.jpg");

    delay(2000);
    // GD.Clear();
    
  //  GD.Begin(BITMAPS);
  //  GD.Vertex2ii(0, 0);
    
    GD.cmd_loadimage(0, 0);
    GD.load("radio4.jpg");
    delay(2000);

    GD.cmd_loadimage(0, 0);
    GD.load("radio5.jpg");
    delay(2000);

    GD.cmd_loadimage(0, 0);
    GD.load("radio6.jpg");
    delay(2000);


    GD.cmd_loadimage(0, 0);
    GD.load("radio7.jpg");
    delay(2000);

    GD.cmd_loadimage(0, 0);
    GD.load("Radio.jpg");
    delay(2000);
  
 GD.swap();
}


Problema casi solucionado, al menos para ver como se afrontan los posibles cuelgues, llevo unos 20 minutos y todo correcto, realizaré mas testeos.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 09, 2016, 08:52 pm
¿Cómo vas con la autorespuesta?, espero que se hayan aclarado todas las dudas jejejeje.

He estado haciendo pruebas con imágenes jpg optimizadas con ayuda de corel paint, para reducir el tamaño de los archivos y mejorar un poco la velocidad de subida a la FT813.

El primer experimento consistió en subir una imagen de 800x480, en conjunto con un grupo de 2 assets de 100 x100 px, y me parece que la pantalla responde, sobre todo el lector microSD externo es bastante estable:

(http://www.mediafire.com/convkey/89c6/ehp8k9lei623ep5zg.jpg)

En el FT801, no se pueden subir imágenes de 480x272 en conjunto con un archivo de assets, se generan algunos errores gráficos por falta de memoria. Quizás se deba a que el conversor de assets, probablemente esté limitado a archivos de 256 kb, ya que está diseñado para el gameduino 2. La familia FT81X, tiene 1 Mb de espacio.

El siguiente paso consistirá en subir un grupo de imagenes de 800x480, dentro de un ciclo contínuo, y mantener la prueba por algunas horas, esto me permitirá saber como se comporta el lector microSD externo.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 10, 2016, 07:59 pm
GD2_FT81X: revisión 1
 (http://www.mediafire.com/download/2ro8astmdfqld93/GD2_FT81X+rev1.rar)
Subiré ejemplos y mejoras de la librería (si es que hay algo mas que hacerle XD), conforme vaya aprendiendo a usarla.

Ejemplos adicionados:

- FT8XX_Test 1: uso de lineas, círculos, manejo de 1 grupo de 11 iconos png, números y texto, números con decimales, imagen de fondo de 800x480 px, uso de polígonos.

(http://www.mediafire.com/convkey/6bdd/12vsascn0x5e6t6zg.jpg)


- FT8XX_Test 2: manejo de imagen de fondo de 800x480 px, uso de un grupo de 2 iconos con movimiento circular

(http://www.mediafire.com/convkey/9f74/ylphbq01zqfkx23zg.jpg)


- FT8XX_slider_test: manejo de sliders verticales y horizontales

(http://www.mediafire.com/convkey/2d4b/zsyoy5wg7qd1393zg.jpg)


- FT8XX_cicloJPG: ciclo continuo de 5 imagenes jpg de 800x450 px

(http://www.mediafire.com/convkey/cccc/z713ia1cewffyxlzg.jpg)


PD: creo que la siguiente pantalla será otra FT81X, para jubilar a las pantallas ILI9341...
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Aug 10, 2016, 08:53 pm
Eres un genio @TFTLCDCyg
Probaré esta revisión.

Una cosa que me queda muy claro, al menos esto he observado, el comportamiento de la microSD es muy diferente de las pantallas mías, en FT8'00 ahora empieza a funcionar bien pero con matices, sin embargo la FT811 no tengo problema ninguno con la SD, misterios? y cuidado las dos con cada una de la shield de Riverdi, osea no hay trucos de cables.

Las pruebas con FT800, lo que si me he dado cuenta, aparte de no superar cierta longitud, todos sin excepción cables que van a la shield o directamente a placa Arduino, han de ser de la misma longitud, pero exactamente la misma, como ponga un cable inferior por ejemplo de 1 cm o 10mm empiezan los problemas. 

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 10, 2016, 09:56 pm
La librería GD2 necesita el mayor porcentaje de la frecuencia del puerto SPI, es por eso que la resistencia asociada a la longitud del cableado es muy importante, hay que mantenerla lo mas bajo posible; por lo que la placa de control debe posicionarse cerca de la pantalla.

En el Teensy 32, es aun mas complicado, hay que mantener una distancia máxima de entre 7 y 10 cm !!!.

Esta es una de las razones por las que el gameduino 2 tiene un diseño en forma de shield.

Personalmente me aventuré a usar la librería GD2 por su simplicidad, con la libreria FT80X de FTDI para arduino, me costó muchas horas descifrar como usar un tag y estuve varado por mas de dos meses tratando de subir una simple imagen jpg, al final lo logré, pero llegó a mis manos un gameduino 2...

(http://www.mediafire.com/convkey/3aef/lahnp53hq133n32zg.jpg)


En 2 minutos logré ver la imagen en pantalla!!!

PD: en cuanto disponga de un tiempo libre le tomo algunas fotos al "shield casero", la idea era no tener cables sueltos, ya que es una pesadilla cablear a cada rato cuando falla una sola conexión.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 20, 2016, 05:52 am
Los chips FT81X tienen varias características relevantes, que merece la pena tratar de usar en la librería modificada de gameduino 2; dado que esta librería se diseñó para la familia FT80X, hay algunos aspectos y herramientas que están limitados a 480x272.

1. Resolución máxima de 800 x 600: 800x480 a partir de 5", (FT80X puede alcanzar hasta 512x512, pero las pantallas comerciales solo tienen 480x272, aún en formatos de 5")

2. Fuentes adicionales con tamaño de 31 a 34 (las pantallas FT80X tienen hasta tamaño 30)

3. Rotación de pantalla

4. Capacidad para reproducir vídeo en formato avi.

1. Uso de la resolución máxima de 800x480
Durante los experimentos encontré que no es posible usar la instrucción vertex2ii fuera de la zona de 510 x 510. Por ejemplo al intentar dibujar un icono perteneciente a un grupo de assets, en la posición (600,400), no aparece nada en pantalla.

(http://www.mediafire.com/convkey/9f74/rfg32hc7apgoo45zg.jpg)
Video: test limitado a 510x510 (https://www.youtube.com/watch?v=MFRAe7-BXmM)

De acuerdo con el manual de programación FT81X, hay dos instrucciones que permiten adicionar pixeles a la instrucción vertex2ii

Code: [Select]
GD.VertexTranslateX(16*x);
GD.VertexTranslateY(16*x);


El valor inicial de x es 0, no tiene definido un valor superior. No obstante, en las pruebas he podido comprobar que es posible usar valores negativos. Al revisar el contenido del archivo GD2.ccp, me di cuenta de que las dos instrucciones están declaradas:

Code: [Select]
void GDClass::VertexTranslateX(uint32_t x) {
 cI((43UL << 24) | (((x) & 131071UL) << 0));
}
void GDClass::VertexTranslateY(uint32_t y) {
 cI((44UL << 24) | (((y) & 131071UL) << 0));
}


Modifiqué el test anterior, en el que se mostraban solo movimientos de rotación dentro del marco de 510x510. La mejor forma de comprobar el alcance de las instrucciones VertexTranslateX y VertexTranslateY, es tratar de dibujar iconos dentro de los 800 pixeles que tiene de largo la pantalla; inserté las instrucciones necesarias para permitir el desplazamiento horizontal.

Code: [Select]
  Xbase = Xbase + velX;
    if(Xbase ==850){Xbase =-400;}
    if(Xbase ==-400){velX=5;}   
   GD.VertexTranslateX(16*Xbase);

(http://www.mediafire.com/convkey/89c6/ehp8k9lei623ep5zg.jpg)
Video: desplazamiento horizontal (https://www.youtube.com/watch?v=2BhwdwgoWNc)

Ejemplo: FT813_Desplazamiento_H (http://www.mediafire.com/download/ohszu661fiu5nro/FT813_Desplazamiento_H.rar)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 21, 2016, 09:44 pm
2-3. Uso de fuentes 31-34 y rotación de pantalla

Las pantallas FT81X incluyen 4 tamaños de fuente adicionales: 31, 32, 33 y 34. Para acceder a ellas hay que usar el comando de coprocesador:
Code: [Select]
cmd_romfont(m,s)
donde m = espacio de memoria para mapa de bits (0-31)
s = tamaño de fuente (16-34)

Sugiero que el llamado del tamaño de fuente se realice dentro de un espacio reservado (Savecontext/Restorecontext), que no interfiera con otras instrucciones de dibujo:

Code: [Select]
GD.SaveContext();
     GD.cmd_romfont(1,34);
     GD.ColorRGB(0xffff00);  
     GD.cmd_text(20, 335, 1, 0, "Fuente 34");
     GD.cmd_number(20, 50, 1, 0, contador);
   GD.RestoreContext();


La parte de rotación se consigue con el siguiente comando
Code: [Select]
cmd_setrotate(r)
Donde r= 0 y 1 para landscape, 2 y 3 portrait

Este comando puede usarse en el setup o bien dentro alguna función o ciclo contínuo dentro del sketch:

Code: [Select]
GD.ClearColorRGB(0x250000); //fondo de pantalla
 GD.Clear();
  GD.ColorA(255);  
  GD.cmd_setrotate(1);
  GD.Begin(BITMAPS);

  

Uní los comandos romfont y setrotate en un ejemplo:

Rotación = 0
(http://www.mediafire.com/convkey/dcec/hcn5y7xi91wod6hzg.jpg)

Rotación = 1
(http://www.mediafire.com/convkey/d18d/bk14z4rw85y6bdwzg.jpg)

Rotación = 2
(http://www.mediafire.com/convkey/7a72/8w73if6ndbaqrdtzg.jpg)

Rotación = 3
(http://www.mediafire.com/convkey/7c58/zfe94agmp53b550zg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 27, 2016, 08:09 pm
En los momentos en los que pensé que tendría un bonito pisapapeles con la pantalla FT813, estuve tratando de hacer funcionar una placa STM32F103 con el bloque de librerías Arduino-STM32.

Finalmente con la pantalla FT813 lista para continuar con el proyecto, logré configurar el St link V2 con la placa de HotMCU STM32F103ZET6, para hacer funcionar una pantalla ILI9341 de 2.8" (SPI , táctil), mediante el IDE 1.6.9 de arduino !!!!.

Pensé que nunca vería algo así...

(http://www.mediafire.com/convkey/ded1/jam406y676z7yl7zg.jpg)

(http://www.mediafire.com/convkey/10a7/xr9faorpbb22h20zg.jpg)

PD: falta hacer funcionar la pantalla táctil y el lector SD... creo que es factible activarlos.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Aug 29, 2016, 01:08 am
Añadiendo un lector microSD

La placa STM32F103ZE cuenta con 3 puertos SPI, el cabezal SPI corresponde al grupo SPI1, en una de las lineas de pines laterales, también tiene habilitados los pines SCK, MISO y MOSI del grupo SPI1. De acuerdo con el datasheet los pines estan en el subgrupo PA:

(http://www.mediafire.com/convkey/8ae0/dq7q5htugzceq36zg.jpg)

En esos pines es posible conectar un lector microSD de 3.3V.

Configurando el panel táctil

Para poder conectar los pines de la pantalla táctil del ILI9341, hay que usar pines digitales, no pines con funciones SPI. En el caso de la STM103, de acuerdo con su datasheet, podemos usar algunos pines del subgrupo PE.

(http://www.mediafire.com/convkey/e224/692c5hxm915zs91zg.jpg)

En el pin PE10, es posible conectar la linea CS del lector microSD. La duda que tengo es si ¿el artilugio en verdad funcionará?, me costó un tiempo tratar de entender como conectar el Stlink V2.

Luego de algunos ajustes, el encabezado del sketch de calibración ha quedado así:
Code: [Select]
#include <UTouch.h>
#include <SD.h>
#include <SPI.h>
#include <Adafruit_GFX_AS.h>    // Core graphics library, with extra fonts.
#include <Adafruit_ILI9341_STM.h> // STM32 DMA Hardware-specific library
#define TFT_CS   PA0                 
#define TFT_DC   PA1               
#define TFT_RST  PA3 
#define SD_CS    PE10
#define TOUCH_ORIENTATION  PORTRAIT
Adafruit_ILI9341_STM tft = Adafruit_ILI9341_STM(TFT_CS, TFT_DC, TFT_RST); // Use hardware SPI
//UTouch(byte tclk, byte tcs, byte tdin, byte dout, byte irq)
UTouch  myTouch(PE15,PE14,PE13,PE12,PE11);


PD: por ahora debo seguir en el trabajo. Mañana haré las pruebas con la pantalla, parece que el sketch de calibración que he migrado a la librería Adafruit_ILI9341_STM, compila sin errores y de hecho ya está en la memoria flash del STMF103.

Me sigue pareciendo muy extraño no usar 2,3,4,  etc. en la definición de pines digitales...
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Aug 30, 2016, 01:32 pm
Buenas.

Ayer recibí las shields universales con las que voy a desarrollar la propia mía casera con el fin de obtener o mejor dicho adaptarlas solo para que estén listas para funcionar.  He estado unos días de vacaciones y hay que retomar el trabajo. Probaré estas ultimas modificaciones tuyas TFTLCDCyg.

Tengo las 4 pantallas en estos momentos con sus propios prototipos donde cada una usa diferentes shields. Voy a buscar un hueco y pongo capturas de las mismas.

Saludos! :)

Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 05, 2016, 02:49 am
Hola TFTLCDCyg.Te molesto nuevamente ,ta hago unas consultas.

Cuento conun display ILI9488  similar al 9344

1) Necesito leer mi tarjeta SD no hay forma de que la pueda leer ,uso una memoria externa y la leo sin problemas pero desde la memoria de la pantalla

2)estoy necesitando hacer un control de registros con RTC ,osea mostrar distintas fallas y la hora en la que sucedio,el tema es que los necesitaría mostrar en mi display y no se bien como hacer para mostrar dicha info en la pantalla ¿tendria que hacer un string y mostrarlo?¿tenes algun ejemplo? ¿como puedo hacer un scroll bar? osea poder mostrar las ultimas 50 fallas

muchas gracias nuevamente
 
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 07, 2016, 05:30 am
Antes deberías ver el porqué no funciona el lector SD, en un momento dado podría ser que tu tarjeta SD no sea compatible.

Personalmente te sugiero tarjetas SD como las kingston de 4 u 8 Gb, clase 4 y clase 10.

Te recomiendo instalar un lector externo micro SD, conectado a SPI, incluso lo puedes construir con un adaptador microSD, hay bastante información en internet, lightcalar ha construido con exito algunos de ellos. Muchas veces el lector incluido en la pantalla presenta fallas y resulta complicado repararlo, sin dañar el TFT que está al otro lado.

El proyecto que tienes en mente se puede encarar con una variable que almacene los 50 valores, y posteriormente te permita almacenarlos en el lector SD. Resolviendo este punto, la presentación de los datos en pantalla, creo que será la parte mas fácil.

De hecho me encuentro estudiando un tema semejante, usando la librería SDFat, los ejemplos que abundan en la red usan la librería SD. En cuanto disponga de un tiempo libre subo los avances.

Hasta el momento ya tengo la rutina para contabilizar las lineas presentes en un archivo de texto guardado en la tarjeta microSD; y con ese valor, armar la base de datos.

El paso siguiente es averiguar como leer solo los últimos 35 datos (en tu caso 50), para solo presentar esa parte de los datos en pantalla.

(http://www.mediafire.com/convkey/0ea0/0pw191cw4416ggazg.jpg)

Mi idea es almacenar en un número entero: la hora de la lectura (hhmm), valor del sensor y conversión de temperatura, luego aplicando algunas divisiones y restas, extraer cada uno de esos valores ya sea para graficarlos o mostralos en una lista en pantalla.

En tu caso, luego de la hora, asignaría un número a cada tipo de aviso, por ejemplo:

0--- encendido
1--- apagado
2--- error de lectura
3--- falla de pantalla
4--- error de almacenamiento

Posteriormente con un select case podría clasificar la base en grupos.
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 08, 2016, 06:09 pm
Hola TFTLDCyg

Ante todo muchas gracias nuevamente por tu respuesta

  Habia probado con un tarjeta SD y no tuve problema .Esta tarjeta estaba por medio de SPI al igual que la que usa la HMI .

          Estas imagenes las puedo usar desde una EEPROM .en este momento estoy usando un arduino Due por la cantidad de señales que tengo ,¿crees que puedo usar un Mega y ver la info por medio de las memorias EEPROM?

son algunas fotos nada mas y todo lo del datalogging


mostrar los valores en la HMI lo pude hacer ,genere un string y lo voy moviendo .



El tema del es como guardo este string y lo muestro osea


falla sobre temperatura        fecha,hora        posicion 1
falla baja tension                fecha,hora        posicion 2
falla boton de emergencia     fecha,hora        posicion 3

en mi cabeza tengo un vector que cargue cada vez que cargo una falla y despues apuntar a ese vector ,obvio lo tengo que guardar en la memoria para que sea retentivo dicho vector .pero no se bien con que herramientas

ya llega el fin de semana que es donde tengo tiempo de jugar,si consigo algún avance te cuento,no hace falta decir  que cualquier idea sirve


Ya que estoy te hago otra pregunta.tengo que hacer desde el tft un numeric input osea un teclado para ingresar un password .¿lo hiciste alguna vez?
saludos










Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 08, 2016, 08:13 pm
Te invito a crear un hilo con las preguntas que tienes, ya que salen del contexto general del presente tema.

Muchas preguntas... aun sigo pensando en ellas.

Es posible almacenar la lista de errores en una tarjeta SD.

Tomando tu idea, se presenta una temperatura que supera los limites de monitoreo, entonces tendrías un error llamado "Temperatura elevada".

Code: [Select]
2016 09 08 12:15:25 Temperatura elevada. Clave 1

La hora y la fecha provienen de un RTC. El valor de temperatura de un sensor.

"Temperatura elevada", está asociada a una variable tipo char, cuyo valor se obtiene de un select case, en el que comparas el valor de la temperatura del sensor, contra los limites de control. El otro valor posible podría ser "Temperatura baja".

Llamemos Error a esa variable tipo char.

El código o clave de error, lo podrías asociar a una variable numérica, que tomará el valor dependiendo de cada una de las posibles fallas que se puedan presentar. No es necesario un procesamiento adicional, puedes asignar una clave a cada una de las fallas que crees que van a ocurrir.

Llamemos code a esa variable tipo int

Imaginemos que usas la librería SDfat, y un DS3231 como RTC, se me ocurre que podrías generar la linea de código de error, Lerror.txt es el nombre del archivo que usaremos para gestionar la lista de errores desde una memoria SD.

La siguiente función, permitirá almacenar la linea de error:

Code: [Select]
void GuardaDatos(){
  if (!myFile.open("Lerror.txt", O_RDWR | O_CREAT | O_AT_END)) {
    sd1.errorHalt("opening Lerror.txt for write failed");
  }
  Serial.print("Writing to Lerror.txt...");

  myFile.print(20);  myFile.print(year);  myFile.print(" ");  myFile.print(month);  myFile.print(" ");  myFile.print(dayOfMonth);   myFile.print(" ");   myFile.print(hour);  myFile.print(":");  myFile.print(minute);  myFile.print(":");   myFile.print(second);   myFile.print(" ");   myFile.print(Error);   myFile.print("Clave: ");   myFile.print(code);  myFile.println(" ");
  
  myFile.close();
  Serial.println("done.");  
}


Esta linea es muy importante

Code: [Select]
if (!myFile.open("Lerror.txt", O_RDWR | O_CREAT | O_AT_END)) {
    sd1.errorHalt("opening Lerror.txt for write failed");
  }


Busca si existe el archivo Lerror.txt, si no existe, lo crea y escribe en él. Si existe, escribe al final.

Cada linea de error, es una cadena de caracteres. Para leer cada una de ellas, en el archivo almacenado en la tarjeta SD, sugiero usar dos funciones.

La primera lee los caracteres presentes en una linea y los almacena temporalmente en la variable tipo char inString (si hay algún fallo, les invito a que lo reporten para mejorar el código)

Code: [Select]
String readLine()
{
  received = "";
  inString = "";  
  int indice = 0;  

  while (myFile.available())
  {
    ch = myFile.read();
    int inChar = ch;

    if (ch == '\n')
    {
      return String(received);
    }
    else
    {
     received += ch;
     inString += (char)inChar;
    }
    Numero=inString.toInt();  //experimento  
  }
  return "";
}


Luego aplicamos una rutina para determinar el número de lineas contenidas en el archivo, esta función imprime linea por linea:

Code: [Select]
void leerNumLineas()
{
 if (!myFile.open("TSD1.txt", O_READ)) {
    sd1.errorHalt("opening TSD1.txt for read failed");
  }  
  Serial.println("Reading TSD1.txt...");
  
  while (myFile.available()){
    readLine();  //ejecuta la lectura sin enviar datos al monitor serie
     NumeroLineas=NumeroLineas+1;
    
     Lectura[NumeroLineas] = Numero; //inString  es la cadena de caracteres extraida de cada linea
        
    Serial.print("  "); Serial.print(NumeroLineas); Serial.print("  "); Serial.print(Lectura[NumeroLineas]); Serial.print("  "); Serial.println(inString);  
   }
  myFile.close();  
}


Faltaría insertar una función o condicional que permita presentar en pantalla solo la parte final: 10, 20 o 50 lineas.

La función anterior también nos permite presentar en el TFT la lista de errores.

Otro tema es hacer que la lista se presente continuamente en pantalla, se podría resolver asociando a cada linea con un vector unitario, pero aun no tengo idea de como conseguirlo.

Con el tema del manejo de contraseñas, no he experimentado, pero es posible conseguirlo, me basaría en el ejemplo UTouch_ButtonTest de la librería Utouch, se podría crear un teclado numérico para ingresar una clave.

El arduino Due no tiene EEPROM, pero eso no es un problema, si en verdad lo necesitas, se podría instalar uno, no he experimentado con ellos. Me parece que el DS1307 incluye una memoria de estas, pero es un pésimo RTC.

Te recomiendo que agregues un lector SD externo, el lector SD del TFT suele dar muchos dolores de cabeza.

PD: no sufran con esas pantallas para sus proyectos, muchas de ellas cuestan lo mismo que una FT810, una FT811, una FT812 o incluso una FT813; es un hecho que aprendí mucho con ellas, no lo niego, pero invertí demasiado tiempo tratando de hacerlas funcionar.

Es mas, con una FT800 o FT801 bastaría para resolver el 50% de los problemas de manejo de pantalla.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 09, 2016, 10:59 am
Dejé en pausa nuevamente el avance con los lectores SD.

Recuperé de experimentos previos un Teensy 3.2. Ajusté la librería GD2 modificada para FT81X y la original  gameduino2.

Bajé los drivers del teensy 3.2 y los instalé en el Arduino-IDE 1.6.3. Obtuve verificación sin errores de algunos ejemplos que funcionan en el arduino Due+FT813.

Veremos que efecto tienen esos 14 MHz extra del teensy 3.2, comparados contra los 84 MHz del arduino Due...
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 09, 2016, 06:29 pm
Gracias tftlcd  .las hmi estas ft800y 801 ¿son las de riverdi? Son las mismas que trabajan con visul tft de mikroelektronika? ¿hay bibliotecas para arduino? O¿ se puede usar algun soft similar al visual tft?
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 09, 2016, 10:28 pm
Gracias tftlcd  .las hmi estas ft800y 801 ¿son las de riverdi? Son las mismas que trabajan con visul tft de mikroelektronika? ¿hay bibliotecas para arduino? O¿ se puede usar algun soft similar al visual tft?
Si: FT801 y FT813, ambas de Riverdi. Otros fabricantes son Mikroe y HotMCU.

Estas pantallas hasta el día de hoy no funcionan con Visual TFT, Mikroe aun no ha liberado al mercado los conectores para pantallas de 5" y 7". Me parece que solo funcionan con pantallas de 3.5" y 4.3". Aunque los drivers ya están disponibles.

Mikroelektronika tiene dos lineas de pantallas: la primer linea las fabrica directamente Riverdi, ellos solo las distribuyen; la segunda linea las produce Mikroelektronika y les incluyó un procesador FT90X

Riverdi y HotMCU sugieren para arduino las librerías creadas por FTDI Chip, pero  son muy complicadas de usar.

En el presente hilo hemos conseguido hacer funcionar las pantallas FT81X, modificando la librería para arduino del gameduino 2. Funciona para el UNO, MEGA, Due y en el Teensy 3.2. Los IDE en los que hemos comprobado que funcionan son 1.5.6 r2, 1.6.3, 1.6.9.

Es una librería bastante simple de usar. Salvo algunas instrucciones, la mayoría de los comandos se pueden consultar en la documentación del gameduino 2 (http://excamera.com/files/gd2book_v0.pdf)

lightcalamar ha trabajado con las pantallas de HotMCU y un servidor, con pantallas de Riverdi.

Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Sep 12, 2016, 09:32 am
lightcalamar ha trabajado con las pantallas de HotMCU y un servidor, con pantallas de Riverdi.
Efectivamente. Las pantallas FT80X y FT8XX de HotMCU las tengo funcionando en pleno rendimiento Estan funcionando realizadas por mi propia Shield, tanto por las dos Shields de Riverdi que compré.

Bien sabe TFTLCDCyg que son las mas económicas del mercado, sin embargo a través de mi compromiso y riesgo las puse en funcionamiento. Como bien dije anteriormente tengo la FT800 y FT811 y de las cuales por problema de tiempo estoy realizando una buena documentación de las mismas. Me ha surgido un contratiempo personal con lo que conlleva las soluciones y ya esta semana misma, tengo un espacio donde terminar dicha documentación.

No desesperes ddwasil, o al menos podrás inclinarte en comprar unas u otras, pero que sepas desde estas lineas que tendrás la información para elegir. Es cuestión de terminar mi PDF que estoy realizando.

Saludos!
 (http://"http://\"http://forum.arduino.cc/index.php?action=profile;u=519127"")
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 12, 2016, 10:30 am
Hey vaya que te lo has tomado muy en serio jejeje. A la espera de ese PDF

Sigo experimentando con un teensy 3.2 y la pantalla FT813. Mas adelante subo los avances.

Retomando los consejos, tocaré el tema del uso de la pantalla táctil resistiva de TFT´s normales y como es que podemos "fragmentarla" para usarla de forma óptima.

Definir una zona táctil

Este aspecto resulta bastante práctico para aprovechar al máximo la pantalla táctil de un TFT con esta prestación.

La idea es acotar una región táctil dentro de 4 vértices, para ello necesitamos fijar 4 valores:
Code: [Select]
xmin, xmax, ymin, ymax

Para el ejemplo emplearé los siguientes elementos:

- TFT ILI9341 de 2.8", con pantalla táctil basada en el chip XPT2046
- Librería Utouch (asumiré que se cuenta con el cableado y calibración correcta)
(http://www.mediafire.com/convkey/25ea/kefnafwmu748c99zg.jpg)

- Librería Adafruit_ILI9341_STM
- Librería Adafruit_GFX_AS
- STM32F103ZET6
- STLink V2
- Arduino IDE 1.6.9

(http://www.mediafire.com/convkey/ded1/jam406y676z7yl7zg.jpg)

Este es el núcleo que permite "fragmentar" la pantalla táctil, para poder crear botones:

Code: [Select]
void MP()
{
  bmpDraw("6oB.bmp", 0, 0);

   colorboton = BLUE;   button28SPI(x21,y21,x22,y22, colorboton);
   tft.setTextColor(WHITE,BLUE);
        tft.setCursor((x21+10),(y21+12));      
        tft.print("BOTON 1");    
  
  while(true)
  {
    if (myTouch.dataAvailable())
    {
      myTouch.read();
      x=myTouch.getX();
      y=myTouch.getY();
              
// Boton 1              
        if ((y>=y21) && (y<=y22))
           {      
          if ((x>=x21) && (x<=x22))
             {
                delay(140);
                estado=estado+1;        
                if(estado==1){Greenbox(x21,y21,x22,y22);}
                if(estado>=2){Bluebox(x21,y21,x22,y22); estado=0;}
             }
           }    
//Boton 1

    }
  }
}


Esta función representa el menú principal del proyecto.

Recomiendo siempre dividir el sketch en funciones simples, de esa forma al adicionar dispositivos, nuevas funcionalidades, nuevos menús, localizar errores, resulta en un proceso mas rápido.

Centrémonos en estas lineas:

Code: [Select]
// Boton 1              
        if ((y>=ymin) && (y<=ymax))
           {      
          if ((x>=xmin) && (x<=xmax))
             {
               //instrucciones que se ejecutarán al tocar el botón
             }
           }    
//Boton 1


Permiten enmarcan en una porción rectangular cualquiera de la pantalla táctil; si las hacemos coincidir con las dimensiones de un rectángulo, o un icono, conseguiremos un botón táctil.

No dispongo por el momento de una cámara con buena resolución, para tomarle nuevas fotos al SMT32+ILI9341 funcionando; sin embargo este concepto lo pueden ver en los siguientes videos:

Shield TFT 2.4" en arduino MEGA (https://www.youtube.com/watch?v=2Agni9t-pUU)

ILI9341 + arduino Due Menu iconos (https://www.youtube.com/watch?v=jeIIPOPkX4E)

ILI9341 + arduino Due Menu botones (https://www.youtube.com/watch?v=zH-H5ND8DCA)

ILI9325D + arduino Due control de ventiladores (https://www.youtube.com/watch?v=zM6ANrpY9Xw)

SmartGPU 3.5" + arduino Due Reproductor de videos (https://www.youtube.com/watch?v=996XZwEmwI4)

PD: sigo sin poder creer que por fin vería una placa STM32F103Z programada por el IDE de arduino. Este es el encabezado:

Code: [Select]
// UTouch_Calibration (C)2013-2014 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics

#include <UTouch.h>
#include <SD.h>
#include <SPI.h>

#include <Adafruit_GFX_AS.h>    // Core graphics library, with extra fonts.
#include <Adafruit_ILI9341_STM.h> // STM32 DMA Hardware-specific library

#define TFT_CS   PA0                  
#define TFT_DC   PA1                
#define TFT_RST  PA3  
#define SD_CS    PE10

Adafruit_ILI9341_STM tft = Adafruit_ILI9341_STM(TFT_CS, TFT_DC, TFT_RST); // Use hardware SPI

#define TOUCH_ORIENTATION  PORTRAIT
//UTouch(byte tclk, byte tcs, byte tdin, byte dout, byte irq)
UTouch  myTouch(PE15,PE14,PE13,PE12,PE11);

uint16_t  color;
// Tabla de colores
#define  BLACK           0x0000
#define RED             0xF800
#define GREEN           0x07E0
#define BLUE            0x102E
#define CYAN            0x07FF
#define MAGENTA         0xF81F
#define YELLOW          0xFFE0
#define ORANGE          0xFD20
#define GREENYELLOW     0xAFE5
#define DARKGREEN       0x03E0
#define WHITE           0xFFFF

uint16_t  colorboton;
uint16_t  colorFONDO=BLACK;

uint16_t colorLightGray = tft.color565(192,192,192);
uint16_t colorGray = tft.color565(127,127,127);
uint16_t colorDarkGray = tft.color565(64,64,64);

// Declare which fonts we will be using
extern uint8_t SmallFont[];

//Zona para variables y constantes
int dispx=320, dispy=240;
int x, y,menu;

//Botones
int x21=0; int y21=75; int x22=105; int y22=114;         // Boton 1
int estado=0;


(http://www.mediafire.com/convkey/7465/kq9w6kdur5jtoilzg.jpg)

Ejemplo: Boton en ILI9341 + STM32F103ZET6 (http://www.mediafire.com/download/wb8lnyra6n2ks6p/STM32F103_ILI9341_Utouch_Boton_test.rar)

Una de las motivaciones para sumergirme en los TFT´s con arduino, fué poder reproducir vídeo. Sé que aun no es posible, sin embargo, el teensy 3.6 ha prometido ser compatible con el IDE de arduino y parece que esa premisa estará disponible en pocos meses más...

Video: ILI9341 con teensy 3.6, reproductor de video (https://www.youtube.com/watch?v=cyGIW3KFrtw)
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 12, 2016, 05:14 pm
Gracias lightcalamar y TFTLCD  .El gran problema que tengo es que en Argentina cuesta mucho conseguir pantallas de este tipo ya que tenemos un régimen de importación bastante conflictivo.

También e pensado en cambiar y  hacer mi proyecto con un HMI Delta que tiene muchas herramientas resueltas (imagenes desde sd,logging ,memoria retentiva ,numeradores armados etc).vi que hay alguna librería pero no e podido interpretarlas por ahora

si puedo probarlo le cuento
gracias por las ayudas
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 13, 2016, 12:24 am
Esos PLC son bastante robustos, aunque te alejarás de arduino. El editor con el que se programan es muy completo y fácil de usar, solo hay que familiarizarse con él revisando ejemplos en internet. Son mas costosos.

En hora buena si puedes conseguir uno de esos dispositivos y consigues hacerlo funcionar en tu proyecto, solo recuerda que las interfaces para conectar sensores o dispositivos, son accesorios adicionales.

Por cierto, hace poco vi un vendedor en la página del "tianguis libre", ubicado en Zárate (Buenos Aires) que tiene entre sus artículos estas piezas:

- Display 5 Tactil Resistivo Spi/qspi - Riverdi   ---  Es un FT812 de 5", de 800x480, con pantalla resitiva

- Break Out Board 20

- Arduino Riverdi Tft Shield

 :o
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 13, 2016, 03:03 pm
Gracias TFT LCD .
                       
                    No hay problema equipamiento Delta consigo y me especializo en eso .

Ingrese en el mundo arduino con el fin de conseguir algo económico y empezó mi problema.Ya que me empece a meter en este mundo .A uno que le encanta la electrónica y el automatismo  se esta haciendo un vicio.
      Aparte esto de que uno pregunta y alguien le responde con muchas ganas es buenísimo.La primera vez que escribí me repondiste con ejemplos ,cargaste una pantalla para mostrar un ejemplo etc

voy a probar ambas alternativas con Riverdi y con Delta si tengo un avance lo publico
saludos 
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 13, 2016, 06:23 pm
Quizás me tome atribuciones que no corresponden por tratar de evitar los "baches", en los que llegué a caer al experimentar con pantallas para arduino de todo tipo. Varias veces sin leer a fondo, pero todo entusiasmado. Con el tiempo pude ver las limitaciones, pero también aprendiendo las ventajas.

Ojalá y la pantalla que consigas ayude a que termines tu proyecto.

Uso de la EEPROM del DS3231 en Teensy 3.2

Recuerdo una pregunta que hiciste respecto al EEPROM, encontré una librería que permite usar la memoria EEPROM de 32 Kb que viene instalada en el DS3231.

En la mesa de experimentos tengo instalado un teensy 3.2, que también tiene un procesador ARM como el due, acabo de comprobar que la librería para gestionar el EEPROM del DS3231 funciona perfectamente.

En cuanto pueda ensamblo el proyecto en el arduino Due y registro los resultados con el EEPROM en esa placa.

Link: librería AT24Cxx (https://github.com/cvmanjoo/AT24Cxx)

Ejemplo de uso:

Code: [Select]
#include <Wire.h>
#include <AT24Cxx.h>
#define i2c_address 0x57

int address = 0;
byte value;

AT24Cxx eep(i2c_address, 32);

void setup() {
 
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
 // escrituraEEPROM();
}

void loop() {lecturaEEPROM();}

void lecturaEEPROM(){
  value = eep.read(address);

  Serial.print(address);
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();

  address = address + 1;
 // if (address == eep.length()) {
 if (address == 25) {
   address = 0;
  }

  /***
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.
    ++address &= EEPROM.length() - 1;
  ***/

  delay(500);
}


void escrituraEEPROM(){
    eep.write(5,100);
    eep.write(10,150);
    eep.write(15,300);  //lo convierte a 44
    eep.write(20,255);  //es el valor máximo que se puede enviar
}


Número de registros de la EEPROM del DS3231 reportado por la librería en el Teensy 3.2: 
(http://www.mediafire.com/convkey/d804/dwvu38io4aa7bc9zg.jpg)

Es una EEPROM de 32Kb, en la que podemos disponer de 32768 registros!
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Sep 13, 2016, 08:40 pm
Gracias por la información .Me parece que es mas facil que usar la memoria sd para conseguir datos remanentes .
lo voy a probar ,lo que me faltaria seria poder ver imagenes almacenadas en la sd
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 16, 2016, 07:53 pm
En efecto, el uso de la EPRROM externa es muy simple.

He estado probando la librería AT24Cxx, funciona muy bien en el teensy 3.2, ya que usa SDA/SCL (Wire).

Aparentemente el mismo sketch que usé en el teensy 3.2 compila sin errores en el due, por cuestiones de tiempo solo he experimentado con el teensy.

Hoy intenté experimentar con AT24Cxx a fondo con el Due. En este arreglo tengo colocado el DS3231 en Wire1 (SDA1/SCL1), y la librería no responde, asumo que es esta situación la que hace que no funcione como debe. Intentaré conectar el reloj en SDA/SCL y experimentaré nuevamente con la librería en el arduino Due.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Sep 18, 2016, 05:22 am
Conecté el DS3231 en SDA/SCL, para poder usar la librería AT24Cxx en el arduino Due. No obtuve señales de respuesta en el monitor serie.

Uso de la EEPROM del DS3231 en arduino Due

Encontré en la red otra variante para leer memorias EEPROM en arduino usando directamente la  librería Wire: http://www.hobbytronics.co.uk/arduino-external-eeprom (http://www.hobbytronics.co.uk/arduino-external-eeprom)

Fue escrita para IDE´s previas a la 1.0, por lo que al usar el ejemplo que muestra la página, en el IDE 1.6.3 con el arduino Due da errores.

Para corregir las fallas hay que modificar estas instrucciones:

Code: [Select]
Cambiar Wire.send      por Wire.write
Cambiar Wire.receive   por Wire.read


El ejemplo compilará sin errores y permitirá usar la EEPROM instalada en el DS3231.

La dirección de la EEPROM en el DS3231 es:
Code: [Select]
0x57

Usé este sketch para escanear los dispositivos I2C:
Code: [Select]
// --------------------------------------
// i2c_scanner
//
// Version 1
//    This program (or code that looks like it)
//    can be found in many places.
//    For example on the Arduino.cc forum.
//    The original author is not know.
// Version 2, Juni 2012, Using Arduino 1.0.1
//     Adapted to be as simple as possible by Arduino.cc user Krodal
// Version 3, Feb 26  2013
//    V3 by louarnold
// Version 4, March 3, 2013, Using Arduino 1.0.3
//    by Arduino.cc user Krodal.
//    Changes by louarnold removed.
//    Scanning addresses changed from 0...127 to 1...119,
//    according to the i2c scanner by Nick Gammon
//    http://www.gammon.com.au/forum/?id=10896
// Version 5, March 28, 2013

////http://playground.arduino.cc/Main/I2cScanner
//    As version 4, but address scans now to 127.
//    A sensor seems to use address 120.
// Version 6, November 27, 2015.
//    Added waiting for the Leonardo serial communication.
//
//
// This sketch tests the standard 7-bit addresses
// Devices with higher bit address might not be seen properly.
//
 
#include <Wire.h>
 
 
void setup()
{
  Wire.begin();
 
  Serial.begin(9600);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}
 
 
void loop()
{
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknow error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");
 
  delay(5000);           // wait 5 seconds for next scan
}


También funciona en SDA1/SCL1, modificando las instrucciones
Code: [Select]
Wire.XXXX  por Wire1.XXXX

Ejemplo: manejo de la EEPROM del DS3231 con arduino Due (http://www.mediafire.com/download/c6crk5yj2de3w1w/Due_DS3231_EEPROM_Wire_full_test_1.rar)
Title: Re: Algunos consejos para usar TFT´s
Post by: Neoxelox on Sep 18, 2016, 05:07 pm
Este mensaje ya esta solucionado, lo borro :P
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Oct 19, 2016, 02:21 am
Hola TFTLCD te vuelvo a molestar ,hacia rato no tocaba mis placas.Estoy utilizando la memoria eepro del rtc sin problemas .Pero ahora necesitaría colocar dentro de la memoria un string, donde colocaria la hora,minutos ,segundo,y una variable char de un data logging

El problema es que no me permite guardar el dato string.
Probastes algunas vez guardar este tipo de dato en la eeprom
gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: josepaul on Oct 25, 2016, 01:11 am
Compañeros alguien a usado la pantalla TFT 3.95" MCUFRIEND, lo que pasa es que solo  encuentro ejmplos pero  de 2.4". Estoy intentando crear un teclado numerico y guardar unos datos al presionar los numeros, veo que la mayoria de comentarios van ligados a la pantalla de 2.4", no se si podran comentar mas sobre esta pantalla de 3.95 ya que no hay mucha documentacion de ella en el foro.
Title: Re: Algunos consejos para usar TFT´s
Post by: ddwasil on Nov 02, 2016, 01:42 am
JosePaul:
        Te paso los link de un post ,ahi coloque varios link que me  fueron muy útiles con este display,tal como dice TFTLCD cada cosa que hay que hacer con este display es muy a pulmon pero se puede.


http://forum.arduino.cc/index.php?topic=413038.msg2870762#msg2870762 (http://forum.arduino.cc/index.php?topic=413038.msg2870762#msg2870762)

La verdad que este display al principio no lo podia prender ,hasta que encontre estas librerias

espero que sirva
saludos
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 14, 2016, 08:01 pm
He dedicado algún tiempo a comprender mejor las instrucciones de la librería y como debe enfocarse la programación.

A diferencia de las pantallas convencionales, con las pantallas FT8XX, hay que pensar que las instrucciones se ejecutan una vez en cada ciclo, posibilitando una sensación de continuidad.

Este comportamiento afecta a todo lo que se envíe a la pantalla, la frecuencia del procesador hace todo el trabajo. Dado que este comportamiento ocurre en promedio a 60 Hz, no podemos percibir los cambios que ocurren en la pantalla: limpiar-dibujar-limpiar-dibujar...

Desplazamiento de texto

Para conseguir el desplazamiento simple, podemos usar las ecuaciones de desplazamiento del movimiento rectilíneo con velocidad constante.

Pensemos en el típico hola mundo; para dibujar el texto en pantalla tenemos la siguiente secuencia:

Code: [Select]
GD.ClearColorRGB(0x103000);
  GD.Clear();
    GD.cmd_text(0, 0, 31, 0, "Hola mundo");
  GD.swap();


Si definimos (PX, PY) como las posiciones (x0, y0), tenemos la posibilidad de dibujar el texto en  cualquier posición.

La velocidad de desplazamiento en el eje X la podemos definir como VelX, si toma el valor 0, el texto no se desplazará. Puede recibir valores positivos y negativos. Conviene definirla como una variable flotante, en lugar de una variable entera, así podemos definir velocidades como 0.1, 1.5, 3.2, etc. En este ejemplo asignaremos el valor 5. Esto es, en cada ciclo el texto avanzará 5 pixeles. Los valores decimales, no implican que el desplazamiento ocurra en fragmentos de pixel, significa que podemos acceder a la resolución 1/16 que tiene la pantalla para cada pixel.

Code: [Select]
//#include <EEPROM.h>
#include <SPI.h>
#include <GD3.h>

float PX= 0, PY = 0, VelX = 5;

void setup()
{
  Serial.begin(9600);
  GD.begin();
  GD.cmd_setrotate(0);
}

void loop()
{
  GD.ClearColorRGB(0x103000);
  GD.Clear();
    GD.cmd_text(PX, PY, 31, 0, "Hola mundo");
  GD.swap();
}


Hasta ahora el texto aun permanecerá en 0,0. La ecuación de posición modificada, no considerará el cambio de tiempo, nos ajustaremos a la frecuencia del procesador. Dependiendo de las necesidades, bien podría incorporarse como factor adicional al desplazamiento. En este caso solo usaremos el cambio de pixel en cada ciclo.

Code: [Select]
PX = PX + VelX;

Insertando la instrucción previa en el código tenemos:

Code: [Select]
//#include <EEPROM.h>
#include <SPI.h>
#include <GD3.h>

float PX= 0, PY = 0, VelX = 5;

void setup()
{
  Serial.begin(9600);
  GD.begin();
  GD.cmd_setrotate(0);
}

void loop()
{
  GD.ClearColorRGB(0x103000);
  GD.Clear();
    GD.cmd_text(PX, PY, 31, 0, "Hola mundo");
    PX = PX + VelX;
  GD.swap();
}


Veremos que el texto se desplaza a la derecha, pero al llegar al limite de la pantalla, el texto no aparece mas.

Debemos establecer condiciones de frontera (como lo leen, un concepto de cálculo diferencial), pero no se asusten, estas condiciones no son otras que los limites en pixeles de la pantalla, en este caso para el FT813 en X va de 0 a 800, en Y va de 0 a 480.

Como la impresión de texto o números son comandos de alto nivel, pueden ser empleados sin problemas en toda la pantalla. (Usan comandos internos basados en vertex2f)

Una condición limite la podemos establecer asignando el valor -240 a PX, cuando su valor sea mayor o igual a 800 (el límite derecho de la pantalla)

Code: [Select]
if (PX >= 800){PX = -240;}

Esto da la impresión de que todo el texto reaparecerá gradualmente desde la izquierda, "luego de perderse" en el limite derecho de la pantalla. Asignamos -240, para que el texto no se imprima repentinamente en 0,0.

El código completo queda así:

Code: [Select]
//#include <EEPROM.h>
#include <SPI.h>
#include <GD3.h>

float PX= 0, PY = 0, VelX = 5;

void setup()
{
  Serial.begin(9600);
  GD.begin();
  GD.cmd_setrotate(0);
}

void loop()
{
  GD.ClearColorRGB(0x103000);
  GD.Clear();
   if (PX >= 800){PX = -240;}
    GD.cmd_text(PX, PY, 31, 0, "Hola mundo");
    PX = PX + VelX;
  GD.swap();
}


En este ejemplo, el texto se mueve continuamente de izquierda a derecha.

Este concepto de desplazamiento simple puede extenderse al movimiento vertical, al movimiento de primitivas, de comandos de coprocesador y de imagenes; básicamente cualquier elemento gráfico que enviemos a la pantalla.

Solo hay que considerar los ajustes necesarios para aquellas instrucciones que solo funcionan con vertex2ii. En ellas debemos usar las instrucciones de traslación en X, Y (GD.VertexTranslateX, GD.VertexTranslateY)


Video: Desplazamiento gráfico (https://www.youtube.com/watch?v=R4tUa0kyUhA)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 16, 2016, 10:14 am
A diferencia de las pantallas convencionales, con las pantallas FT8XX, hay que pensar que las instrucciones se ejecutan una vez en cada ciclo, posibilitando una sensación de continuidad.

Hola.
Escribo este mensaje citándote y dándote toda la razón. No es en sí la complejidad de programar las FT8XX sino que todo lo que aprendes con Arduino luego no te vale para estas pantallas... bueno matizo, una parte si te ayuda pero en la practica es muy pero que muy diferente al código básico de cualquier proyecto con otras pantallas.

Por ejemplo, hasta donde he aprendido el void loop casi no vale para nada, lo que genera son conflictos mal funcionamiento, y muchos me reprochareis tal decisión pero es así. Como bien dices TFTLCDCyg es otra forma de programar.

Con tus ejemplos he aprendido enormemente que una función tiene que tener su propio bucle de lo contrario no funciona, parpadeos, desvanecimientos y largos problemas de escritura en el LCD.
Usando un do .. while se tiene el problema resuelto  en casi todas las funciones a realizar.

 A todo ello como un simple código de imprimir un reloj basado en el DS107, tiene todos los ingredientes para que funcione a alto nivel de código siguiendo tus ejemplos. He estado estudiando la estructura de como funciona la librería Gamenduino y no solo se "traga" lo que escribes, sino que cuando la entiendes es muy fácil representar lo que se ha de mostrar en pantalla.

Agradezco muy mucho tu ayuda por obtener texto en movimiento (Scroll Text) de hecho ya estoy en marcha con un proyecto sobre mi primer código en serio con mi FT800.

Esta tarde pondré mi proyecto ya iniciado y con sus posibles sorpresas.

Saludos!

Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 16, 2016, 06:21 pm
Justo me faltaba ese paso en el ejemplo.

Algunas veces funciona muy bien el void loop, pero cuando aumentas la complejidad del sketch, presentando lectura de sensores, los datos de un RTC, imágenes, tamaño de letra especial (32-34 en FT81X) o transparencias, la pantalla se puede tornar inestable cuando agregamos alguna instrucción en alguna posición en la que no debería estar.

Al borrar lineas tratando de corregir el fallo, podemos toparnos con...
(http://www.mediafire.com/convkey/1471/ujnp7pl45674jojzg.jpg?size_id=6)

El ejemplo de desplazamiento de texto separado en funciones podría quedar así:

Code: [Select]
#include <SPI.h>
#include <GD3.h>

int x=400, y=240;

void setup()
{
  GD.begin();
  GD.cmd_setrotate(0);
  MP();
}

void loop(){}

void MP()
{
  while(1)
  {
    GD.ClearColorRGB(0x103000);
    GD.Clear();
     DesplazamientoH();
     DesplazamientoV();
     GD.SaveContext();
      GD.ColorA(150);
      GD.cmd_romfont(1,34);   //Usa las fuentes adicionales del FT81X: 32, 33, 34
      GD.ColorRGB(0,0,0);  GD.cmd_text(393, 253, 1, OPT_CENTER, "Hello world");
      GD.ColorRGB(255,0,0);  GD.cmd_text(400, 240, 1, OPT_CENTER, "Hello world");
     GD.RestoreContext();     
    GD.swap();
  }
}

void DesplazamientoH()
{
  if(x<=-150){x=900;}
    GD.ColorRGB(0,255,0);
    GD.cmd_text(x, 240, 31, OPT_CENTER, "Hello world");
  x=x-2;
}

void DesplazamientoV()
{
  if(y<=-100){y=500;}
    GD.ColorRGB(255,255,0);
    GD.cmd_text(400, y, 31, OPT_CENTER, "Hello world");
    GD.cmd_text(400, y+35, 28, OPT_CENTER, "FT81X, 800x480, GD3");
    GD.cmd_text(400, y+60, 28, OPT_CENTER, "Riverdi breakout-20");
    GD.cmd_text(400, y+85, 28, OPT_CENTER, "Teensy 3.6, Arduino");
  y=y-5;
}


PD: ¿cómo te fue con el "problema táctil"?
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 17, 2016, 10:01 am
PD: ¿cómo te fue con el "problema táctil"?
Todavía no lo he probado por falta de tiempo. Voy a probar tu consejo. Concretamente de usar el MEGA donde ya tenga el código correcto y poner la FT811 con el táctil dudoso. (buena opción, no se me había ocurrido).

En estos momentos estoy atascado con un código para representar mi modulo GPS, concretamente este modulo (http://www.banggood.com/es/GY-NEO6MV2-Flight-Controller-GPS-Module-For-Arduino-EEPROM-MWC-APM-2_5-p-915384.html?rmmds=myorder) y su correspondiente librería  ( libreria TinyGPS++ (http://arduiniana.org/libraries/tinygpsplus/), en FT800. No me salen los decimales de longitud y latitud.
He leído este mensaje en el foro de James (http://gameduino2.proboards.com/thread/101/print-float-double) esto para poder convertirlo a GD2 pero me esta costando.

Te adjunto el código usado. A todo veras que el loop, no lo uso.
El problema que tengo esta que imprime bien el serial pero no soy capaz de representar los decimales en la FT800. . . .  en la parte del fichero "gps" en donde tengo el problema.



Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 17, 2016, 08:54 pm
Sube algunos ejemplos de los números que quieres imprimir en pantalla.

Te sugiero usar la presentación de números decimales, como una función aislada, que solo recibirá el número que quieres presentar, la posición (x,y) y el número de decimales que quieres mostrar.

Esta es mi versión de la función de impresión de flotantes:

Code: [Select]
static void plotfloat(int x, int y, float f, int Ndec, int fontsize)
{
 //Parte entera y punto decimal
 GD.cmd_number(x - 2, y, fontsize, OPT_RIGHTX | OPT_SIGNED, int(f));
 GD.cmd_text(  x,     y, fontsize, 0, ".");
 //Parte entera y punto decimal

//Parte decimal
if (Ndec==1){
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(10 * abs(f))); // 1 decimal
 } 
if (Ndec==2){
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(100 * abs(f))); // 2 decimal
 }
if (Ndec==3){ 
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(1000 * abs(f))); //3 decimal
 }
//Parte decimal
}
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 18, 2016, 02:19 am
ILI9341 con CD4050

El chip CD4050, en específico el CD4050BE, nos puede ahorrar muchos dolores de cabeza con el cableado de pantallas ILI9341-SPI de 2.2", 2.4" y 2.8".

Este es el conexionado:
(http://www.mediafire.com/convkey/78d2/6weyucz4cajbuq4zg.jpg)

La ventaja al usar este chip es que podemos manejar mejor el cableado entre la pantalla y el MCU de 5V; lo que además nos da la flexibilidad de instalarlo en un shield personalizado que puede funcionar sin problemas en una placa UNO o en un MEGA.

(http://www.mediafire.com/convkey/d380/4edp5q48up356dkzg.jpg)

(http://www.mediafire.com/convkey/342a/v6cy64489s41ul5zg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 18, 2016, 09:36 am
Buenas.
Mas o menos lo que quiero mostrar en pantalla FT800 son las coordenadas de latitud y longitud con sus decimales. Veamos. Por ejemplo la cuidad de Gerona (España) tiene;

Latitud . 41,9794
Longitud: 2,8214

Para representar en el Serial los cuatro decimales que usa el ejemplo de la librería TinyGPS++ es esta función;
Code: [Select]

static void printFloat(float val, bool valid, int len, int prec)
{
  if (!valid)
  {
    while (len-- > 1)
      Serial.print('*');
    Serial.print(' ');
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1); // . and -
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(' ');
  }
}

y su constructor es;
Code: [Select]

  printFloat(gps.location.lat(), gps.location.isValid(), 11, 4);  // LATITUD
  printFloat(gps.location.lng(), gps.location.isValid(), 12, 4);  // LONGITUD

donde, 4 es el numero decimales y se podría poner 6 , 5 etc...
y lo imprime en el Serial.
Para imprimir en un LCD 16x02, la función modificada es esta función;
Code: [Select]

 static void print_float(float val, float invalid, int len, int prec)
  {
    if (val == invalid)
    {
      while (len-- > 1)
        lcd.print('*');
      lcd.print(' ');
    }
    else
    {
      lcd.print(val, prec);
      int vi = abs((int)val);
      int flen = prec + (val < 0.0 ? 2 : 1);
      flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
      for (int i=flen; i<len; ++i)
        lcd.print(' ');
    }
    smartdelay(0);
  }


Con un TFT con chip ILI9481 usando la librería UTFT de .rinkydinkelectronics (http://www.rinkydinkelectronics.com/library.php?id=51) usando la construcción;
Code: [Select]

myGLCD.printNumF(gps.altitude(), 4, RIGHT, 180);

se imprime la latitud con 4 decimales, sin modificar la función printFloat pero con GD2 y con GD.cmd_number aquí estoy atascado. Como lo ves TFTLCDCyg?

Creo se tendría que modificar la función GD.cmd_number de la librería GD2. O en su caso crear una función llamada; GD.cmd_numberF. En la librería UTFT hay dos funciones para representar números en pantalla; la myGLD.printNumI y la myGLD.printNumF, donde esta ultima es la que imprime números flotantes, esta es mi opinión.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 19, 2016, 06:26 am
Hay que usar algunas instrucciones extra en GD2/GD3.

Parece que esta es la linea clave

Code: [Select]
Serial.print(val, prec);

En la que obtienes el valor de las coordenadas decimales. Supongo que la llamas al presentar cada uno de los valores, ya sea latitud o longitud.

En el primer llamado obtienes: Latitud: 41,9794
Y para el segundo llamado:     Longitud: 2,8214

val es una variable de tipo flotante (float)

Cada vez que obtengas un valor para val, debes llamar a la función externa de presentación del valor en pantalla.


La función que sugerí lineas arriba, basada en el ejemplo que indicó James, debe incluir una cuarta alternativa para manejar 4 decimales. Quedaría así:


Code: [Select]
static void plotfloat(int x, int y, float f, int Ndec, int fontsize)
{
 //Parte entera y punto decimal
 GD.cmd_number(x - 2, y, fontsize, OPT_RIGHTX | OPT_SIGNED, int(f));
 GD.cmd_text(  x,     y, fontsize, 0, ".");
 //Parte entera y punto decimal

//Parte decimal
if (Ndec==1){
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(10 * abs(f))); // 1 decimal
 }  
if (Ndec==2){
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(100 * abs(f))); // 2 decimales
 }
if (Ndec==3){  
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(1000 * abs(f))); //3 decimales
 }

if (Ndec==4){  
 GD.cmd_number(x + 8, y, fontsize, Ndec, int(10000 * abs(f))); //4 decimales
 }

//Parte decimal
}


Veamos un ejemplo en concreto con los valores que señalas, complicándolo un poco como si obtuvieramos valores errráticos del GPS:

Code: [Select]
//#include <EEPROM.h>
#include <SPI.h>
#include <GD3.h>

void setup()
{
  GD.begin();
  GD.cmd_setrotate(0);
}

float latidud, longitud;

float latitudint, latituddec;
float longitudint, longituddec;

void loop()
{
  GD.ClearColorRGB(0x000020);
  GD.Clear();

  latitudint = random(35,45);
  latituddec=  random(9999);
  latitud = ((latitudint*10000)+latituddec)/10000;

  GD.cmd_text(100, 100, 31, 0, "latitud:");
   printfloat(325, 100, latitud, 4, 31);

  longitudint = random(1,5);
  longituddec=  random(9999);
  longitud = ((longitudint*10000)+longituddec)/10000;

  GD.cmd_text(100, 150, 31, 0, "longitud:");
   printfloat(325, 150, longitud, 4, 31);  

  delay(1000);
  GD.swap();
}

static void printfloat(int x, int y, float f, int Presc, int fontsize)
{
 //Parte entera y punto decimal
 GD.cmd_number(x - 2, y, fontsize, OPT_RIGHTX | OPT_SIGNED, int(f));
 GD.cmd_text(  x,     y, fontsize, 0, ".");
 //Parte entera y punto decimal

 Presc = abs(Presc);
 
//Parte decimal
if (Presc==1){
 GD.cmd_number(x + 9, y, fontsize, Presc, int(10 * abs(f))); // 1 decimal
 } 
if (Presc==2){
 GD.cmd_number(x + 9, y, fontsize, Presc, int(100 * abs(f))); // 2 decimales
 }
if (Presc==3){ 
 GD.cmd_number(x + 9, y, fontsize, Presc, int(1000 * abs(f))); //3 decimales
 }
if (Presc==4){ 
 GD.cmd_number(x + 9, y, fontsize, Presc, int(10000 * abs(f))); //4 decimales
 }
if (Presc==5){ 
 GD.cmd_number(x + 9, y, fontsize, Presc, int(100000 * abs(f))); //5 decimales
 }
if (Presc==6){
 GD.cmd_number(x + 9, y, fontsize, Presc, int(1000000 * abs(f))); //6 decimales
 }
 //Parte decimal
}


printfloat, sería la función candidata para imprimir flotantes en GD2/GD3, le podemos añadir mas salidas decimales, hasta donde lo permita la resolución del arduino. Solo que no he podido incluirla en la librería con éxito para llamarla como GD.printfloat, saltan algunos horrores de compilación XD.

La estructura es bastante simple

Code: [Select]
printfloat(posición x, posición y, variable flotante, número de decimales, tamaño de la fuente);

En el caso de la secuencia de instrucciones de tu proyecto con el GPS, quedaría algo así:
Code: [Select]
Serial.print(val, prec);
printfloat(x[0], y[0], val, prec, 30);


Podrías usar un contador de presentación, para manejar las posiciones relativas para latitud y longitud, para que no se sobreescriban al llamar la función que calcula val:

Code: [Select]
x[0], y[0], corresponden a la posición de latitud
x[1], y[1], corresponden a la posición de longitud


PD: luego que consiga poner a punto el multisensor MAX1668 y el MAX6697, incluiré esa función en la librería, podría resultar muy útil
Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Nov 20, 2016, 09:53 am
Que grande hermano este va para marcadores pero ya!!

Muchas gracias por compartir, con lo que me gustan las pantallitas voy a disfrutar mucho!!
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 21, 2016, 10:17 pm
Gracias, se hace lo que se puede en los ratos libres.

Un ejemplo mas para la presentación de números decimales, mediante la función GD.printNfloat. Está adaptado para pantallas con resolución de 800x480 px; no obstante la función está presente en la librería GD2 y tiene los los mismos parámetros generales que en GD3.

Code: [Select]
//#include <EEPROM.h>
#include <SPI.h>
#include <GD3.h>

void setup()
{
  GD.begin();
  GD.cmd_setrotate(0);
  agujasimple();
}

void loop(){}

float Xb = 400, Yb = 300, angP=-160, lp = 150;
float Xp, Yp, velp =1;

long previousMillis;
long interval = 0;
float pi=3.1415926535897932384626433832795;

void agujasimple()
{

while(1)
 {  
  GD.ClearColorRGB(0x002000);  //fondo uniforme
  GD.Clear();  
  GD.get_inputs();

  if (abs(angP)<160){angP=-160; velp=1*abs(velp);}
  if (abs(angP)>380){angP=-380; velp=-1*abs(velp);}

  Xp = Xb + lp * cosf(angP*pi/180);
  Yp = Yb - lp * sinf(angP*pi/180);

  GD.printNfloat(100, 50, Xp, 2, 31);
  GD.printNfloat(300, 50, Yp, 2, 31);
  GD.printNfloat(500, 50, angP, 0, 31);
  
  GD.SaveContext();
   GD.Begin(LINES);
   GD.LineWidth(35);
   GD.Vertex2f(Xb*16, Yb*16); // inicio
   GD.Vertex2f(Xp*16, Yp*16); //  fin  
  GD.SaveContext();    

  unsigned long currentMillis = millis();        
  if(currentMillis - previousMillis > interval)
  {
    previousMillis = currentMillis;      
    angP = angP - velp;
  }
   GD.swap();
 }
}
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 28, 2016, 06:55 pm
Efectivamente corroboro que la nueva función GD.printNfloat funciona sin problemas.

Por otro lado voy a retomar el problema de las tarjetas microSD con la librería Gameduino2, Porque estoy atascado  con este problema. Con Arduino DUE no hay problema, ya que la lógica de 3,3 Voltios donde también la microSD necesita, trabaja a la perfección.

El problema viene con Arduino o UNO o MEGA con shields microSD. He estado investigando que puede (o es un problema) de la logica de ambas placas. He estado por otro lado averuguando los divisores del bus SPI sin dar con el problema.

Compré 2 shields de Riverdi para Arduino donde la microSD funciona al 100% y con muchísima estabilidad.
Tengo varias shields microSD donde casi todas al menos 6 modelos no quieren trabajar y he aquí la ecuación. En la pagina de Riverdi  donde la documentación es esta (http://riverdi.com/wp-content/uploads/datasheet/Arduino_Riverdi_TFT_shield_Rev.1.2.pdf) del escudo y he estudiado el esquema del mismo donde se usa un circuito integrado NVT2008QB que es un Bidirectional voltage-level translator (Adaptador de  Nivel de voltaje bidirecional) y esta en la pagina numero 9. Nos encontraremos con;

(http://i.imgur.com/SJ4f7dI.jpg)

el pin 2 y 19 son el establecimiento de VCC y de ellos depende la lógica a usar.

Bien si la shield de Riverdi funciona con Arduino UNO y MEGA en estas condiciones, todas las pruebas que se realicen funcionan inestables o al limite del bus SPI (que es muy caprichoso) al menos con estas pantallas FT(XX con cualquier tipo de shield SD del mercado. Y aquí mi nueva disposición para intentar realizar después de mucho investigar poner un lector microSD normal con un IC llamado;
TXS0108E concretamente este modulo;

(http://g02.a.alicdn.com/kf/HTB1aN.eKFXXXXcQXXXXq6xXFXXXx/Free-shipping-1pcs-3-3V-5V-TXS0108E-8-Channel-Logic-Level-Converter-Convert-TTL-Bi-directional.jpg)

y creo se cumplirá las mismas condiciones de adaptación de niveles lógicos como ocurre en la shield de Riverdi.
Les mantendré informados, ya que me llega el modulo en algunos días.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 28, 2016, 11:03 pm
Buenas.
Del mensaje anterior voy a seguir con el ya que tengo material pedido y pagado.
Pero acabo de descubrir algo que ya me quedo a cuadros.

Tomen asiento y empieza la película de esta noche. Es de genero Terror-Cómica

Parte del Terror

Llevo unas 3 semanas del cual no me lee la microSD en Gameduino2. Revisado todos los lectores en mi posesión, realizando otros a mano caseros y no hay forma. Estas 3 semanas con el famoso regalito, concretamente este;

(http://www.mediafire.com/convkey/1471/ujnp7pl45674jojzg.jpg?size_id=6)

De hecho el tema de la SD no la tocaba desde al menos el mes de Septiembre donde todo va bien. Hasta hace 3 semanas...

Parte Cómica

Esta es la buena. Ya me funciona mi shield casera que monté alla por el mes de Julio y esta si que me funcionaba bien. Acabo de descubrir del porque.
Todos las imágenes sea para FT800 y/o FT811 las tengo dentro de la SD y la ultima vez usada fue como dije por el mes 9 del corriente año. Como sabía que esta funcionaba bien, la he puesto en mi shield de Riverdi y zas... no funciona la microSD.

Entonces pongo la SD al PC y perfecto, todos los ficheros visibles, concretamente unos 296 que su peso son unos 25 MBytes (la microSD es de 4GBytes marca Kingston) vuelvo a Riverdi y no funciona. Observo los ficheros de configuración de la librerías tanto GD2 y GD3 y nada que no se ve, solo el famoso regalito (como en Windows, la pantalla de la muerte, y que bonita es la condenada toda ella azul... jejeje).

Entonces me da por reír, pero una risa de las buenas ... como acaba la película?, formateo la SD en el PC, le vuelvo a poner todos los ficheros de respaldo exactamente todos los 296 y la luz, con la shield de Riverdi ya funciona. Entonces dije lo mismo de tanto sacar la SD, realizar pruebas, sacar meter algo ha pasado. No lo entiendo. Desde luego la SD estaba bien, con sus ficheros cada vez que la he puesto al PC. Cosas de gnomos he pensado y ya pueden reír un rato, pero casi que pierdo la paciencia.

Ahora los créditos de la película

Cada vez que suban un fichero a la SD lo mejor es crear una carpeta en el PC, formatear la SD y copiar dichos ficheros.
No ha sido muy larga la película, pero he soñado estas tres semanas con todo tipo de tarjeteros SD, cables y por no contar que han sido algunas noches hasta desveladas. Espero les ayude mi experiencia.



Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 29, 2016, 07:19 pm
Vaya al final solo era formatear la tarjeta... que bien que ya funciona nuevamente el proyecto completo. A la espera de ese radio modificado.

Por cierto, ¿cuál es el tamaño máximo de parlante o bocina que puede soportar el PAM8403?, conseguí un par de esos amplificadores con control de volumen.

Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Nov 30, 2016, 01:05 am
Vaya al final solo era formatear la tarjeta... que bien que ya funciona nuevamente el proyecto completo. A la espera de ese radio modificado.

Por cierto, ¿cuál es el tamaño máximo de parlante o bocina que puede soportar el PAM8403?, conseguí un par de esos amplificadores con control de volumen.
Pues si esta fue la solución. Formatear la SD. Increíble y casi me vuelvo loco.

Hoy he realizado por modificación dos shields SD por el mismo concepto que puse en su día de este esquema el cual funciona correctamente al menos en Arduino MEGA este es ;

(http://i.imgur.com/N8lDbKW.jpg)

(Está en la pagina numero 3 de este hilo)

A todo ello siempre me he planteado del porque usar Arduino UNO en una FT8XX, creo es de risa, dos sensores y para que mas. Aun así Arduino MEGA por sus 8 veces mas de flash, creo que funciona los niveles del BUS SPI diferente del modelo UNO al MEGA (lo voy a estudiar, porque merece la pena), y creo TFTLCDCyg que me vas conociendo cada día mas, a lo anterior comentado.
Por un lado el MEGA (todo por confirmar) acepta niveles lógicos entre 1,8 a 5, mientras el modelo UNO de 4,5 a 5 en BUS SPI. Ya tengo tiempo para estudiar un rato.

Otro hincapié, desde mi modesta opinión creo James tiene el proyecto semi-abandonado concretamente a la librería que desarrolló, pero bueno son temas que pasan.

Sobre los amplificadores de BF PAM8403, son una maravilla. Baratos y eficaces. El único problema es que a la entrada le pongas unos condensadores electrolíticos de 4,7uF o 10uF,  para eliminar la continua, llevan de serie unos de 100nF (y no filtran la cc) te recomiendo los compres por paquetes de 5 o 10, compré en Banggood 5 piezas por 6€. Alimentados a 5Vcc y 3Wx2 canales una gran elección.

El parlante (altavoz) en mi proyecto Radio FM los tengo de 4 pulgadas. Probé este modulo en unas bafles de dos vías con un boffer de 8 pulgadas y la verdad tiene calidad.

Finalizo este mensaje escribiendo que ya tengo casi todo en parte del prototipo del manual que escribir anteriormente en este mismo hilo sobre las pantallas de;

(http://www.hotmcu.com/includes/templates/pure_black_free/images/logo.gif)

Donde se tendrá como conectar;


Hasta la próxima. Saludos!

Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Dec 25, 2016, 10:48 am
No me deja descomprimir los archivos que compartes en el mensaje #4 (http://forum.arduino.cc/index.php?topic=346755.msg2424353#msg2424353) Desde Ubuntu, concretamente estos "Sketch e imagenes" ¿esta corrupto o desde windows se puede? ¿alguien ha probado?

Quiero poner una imagen en mi SD para el fondo de la pantalla. Y Quería ver como lo haces en los archivos compartidos pero no he podido desde Ubuntu.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 26, 2016, 12:56 am
Todos los ejemplos están orientados a Windows; están alojados en un servidor de almacenamiento. Te recomiendo usar una PC con windows, bajas el archivo y listo. El sketch e imágenes están en un archivo rar.

Verifiqué el link de descarga desde una pc con windows y baja sin problemas.
Title: Re: Algunos consejos para usar TFT´s
Post by: bubu_54 on Dec 27, 2016, 10:48 am
Buenos días chicos, estoy empezando a tocar el tema del Arduino, ya se de programación por lo que la parte de software me puedo hacer con ella, pero de hardware no controlo tanto, entonces os comento...

Quiero hacer un dashboard para juegos de coches, el típico que se ve en un F1 por ejemplo, con la srpm del motor, la marcha engranada, velocidad, tiempos por vuelta... etc.

(http://www.race-technology.com/upload/products/NewImages/Dash2.jpg)

(http://static1.1.sqspcdn.com/static/f/696403/9352821/1289372129100/DASH1.png?token=fH0jnZ%2Fo9mzKhIdWYI2aE9zqtjc%3D)

Toda esa información ya la tengo en un programa de C# y almacenada en un array de bits que luego le paso al arduino (Uno y Nano en mi caso, tengo los dos), hasta ahora empleo un display TM1638 pero quiero pasar a la versión 2.0 y hacerlo en un display gráfico, la pregunta es, este display me serviría?

Display tft (https://www.aliexpress.com/item/3-95inch-TFT-LCD-for-uno-r3-ili9488-driver/32715447497.html?ws_ab_test=searchweb0_0,searchweb201602_3_10065_10068_10000009_10084_10083_10080_10082_10081_10060_10061_10062_10056_10055_10054_10059_10099_10078_10079_427_10103_10073_10102_428_10096_10052_10050_10051,searchweb201603_9,afswitch_3&btsid=c43e1148-89ff-4618-90c3-094140134abb)

Que tal va en cuanto a tiempo de refresco de la pantalla? Voy a presentar valores en tiempo real y necesito que sea rápida, y el tema de librerías? Hay algo decente o es un charco para programarlo?

Muchas gracias y un saludo.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 27, 2016, 08:21 pm
Esas pantallas están diseñadas específicamente para esas funciones, son de cristal líquido. Hay muy pocas opciones para arduino que pueden conseguir ese tipo de resultados.

Si ya tienes las señales, es decir variables e interface con tu programa de PC (juego o simulador), solo tienes que convertirlas en números, de allí el paso a la representación mediante gauges, o diales depende de tu imaginación.

Aunque en el tema he tratado de tocar las opciones de TFT y librerías que conozco; me he centrado en pantallas de la familia FT8XX, dado que son por mucho las mejores para enfrentar ese tipo de retos en arduino.

(http://www.mediafire.com/convkey/cbac/cydpsqv59tb93uzzg.jpg)

La librería GD3 que hemos tratado de poner a punto entre ligthcalamar y un servidor, es bastante capaz de conseguir lo que planteas.

Te sugiero un teensy 3.2 o mejor aún un 3.6, por el tema del tamaño del espacio físico y de programación. Luego viene el arduino Due, MEGA, y posiblemente el nano que tienes, pero es probable que te quedes sin espacio para subir el sktech.

Esto solo fué un ejercicio para probar el potencial de la librería GD3, puede ser un punto de partida en lo que buscas con la versión 2.0:

Video: FT813+GD3+teensy 3.6, gauge lineal (https://www.youtube.com/watch?v=JXUWb5no7O4)

Existen algunas versiones de pantallas FT80X que tienen una placa AVR instalada que se pueden programar en el IDE de arduino. No las he podido usar, sin embargo les veo potencial para funcionar con la libreria GD2

FTDI chip (http://www.ftdichip.com/Products/Modules/VM800P.html)

Newheaven (http://www.newhavendisplay.com/development-tools-shields-and-capes-c-979_981.html)

Pueden ser alternativas al gameduino 2 (http://excamera.com/sphinx/gameduino2/), pantalla que originó todo esto de la GD3.

Recientemente FTDI creó una plataforma llamada Cleo (http://www.ftdichip.com/EVE/EVESolutions.htm), tiene opciones de 3.5 y 5", incluyen un procesador de diseño propio, que se puede programar con el IDE de arduino, no las conozco a fondo pero parecen buenas opciones.

Mikroelektronika tambien tiene una linea de pantallas con procesador de programación incluido (http://www.mikroe.com/mikromedia-hmi/), pero los costos son algo elevados, ademas de que se programan con un entorno, por el que hay que pagar una licencia.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 27, 2016, 08:53 pm
De las pantallas de Newheaven que incluyen un MCU, la que me parece mas interesante es esta:

http://www.newhavendisplay.com/development-tools-shields-and-capes-c-979_981.html (http://www.newhavendisplay.com/development-tools-shields-and-capes-c-979_981.html)

Me permito transcribir tal cual las especificaciones que señala el fabricante, ya que he investigado desde hace un buen rato una pantalla que pueda leerse bien en condiciones con luz solar:

Code: [Select]
NHD-4.3CTP-SHIELD-N

• Sunlight Readable Arduino Shield
• NHD-4.3-480272EF-ASXN#-CTP display
• 5-point Multitouch Capacitive Touchscreen
• FTDI FT801 Embedded Video Engine
• High Brightness 830 cd/m2
• 18-bit, 262K Color Depth
• On-board Audio Power Amplifier
• PWM Backlight Control
• MicroSD Card Reader
• Open-Source Hardware & Software
• RoHS compliant


Prospección interesante para proyectos en los que hay que usar la pantalla en exteriores: como un GPS o una estación de monitoreo de clima. Me da la impresión de ser una especie de evolución del Gameduino 2.
Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Dec 27, 2016, 08:54 pm
Gracias TFTLCDCyg probare desde Windows.

Estoy teniendo problemas para usar una imagen .bmp desde la SD con ili9341_due Cambie a esta librería porque me lo aconsejaste y la verdad es que he aprendido mucho.

Con la SD tengo mis dudas ¿Que formato le doy fat32? Uso una de las pantallas que tu tienes una qvga 2.2 tft spi 320x240
¿Tengo que conectar los 4 pines de la parte j4? Para usar la SD

Otra cosa que me encanta de tus post son los medidores "gauge" y termómetros que haces.
Title: Re: Algunos consejos para usar TFT´s
Post by: bubu_54 on Dec 27, 2016, 09:20 pm
Esas pantallas están diseñadas específicamente para esas funciones, son de cristal líquido. Hay muy pocas opciones para arduino que pueden conseguir ese tipo de resultados.

Si ya tienes las señales, es decir variables e interface con tu programa de PC (juego o simulador), solo tienes que convertirlas en números, de allí el paso a la representación mediante gauges, o diales depende de tu imaginación.

Aunque en el tema he tratado de tocar las opciones de TFT y librerías que conozco; me he centrado en pantallas de la familia FT8XX, dado que son por mucho las mejores para enfrentar ese tipo de retos en arduino.

(http://www.mediafire.com/convkey/cbac/cydpsqv59tb93uzzg.jpg)

La librería GD3 que hemos tratado de poner a punto entre ligthcalamar y un servidor, es bastante capaz de conseguir lo que planteas.

Te sugiero un teensy 3.2 o mejor aún un 3.6, por el tema del tamaño del espacio físico y de programación. Luego viene el arduino Due, MEGA, y posiblemente el nano que tienes, pero es probable que te quedes sin espacio para subir el sktech.

Esto solo fué un ejercicio para probar el potencial de la librería GD3, puede ser un punto de partida en lo que buscas con la versión 2.0:

Video: FT813+GD3+teensy 3.6, gauge lineal (https://www.youtube.com/watch?v=JXUWb5no7O4)

Existen algunas versiones de pantallas FT80X que tienen una placa AVR instalada que se pueden programar en el IDE de arduino. No las he podido usar, sin embargo les veo potencial para funcionar con la libreria GD2

FTDI chip (http://www.ftdichip.com/Products/Modules/VM800P.html)

Newheaven (http://www.newhavendisplay.com/development-tools-shields-and-capes-c-979_981.html)

Pueden ser alternativas al gameduino 2 (http://excamera.com/sphinx/gameduino2/), pantalla que originó todo esto de la GD3.

Recientemente FTDI creó una plataforma llamada Cleo (http://www.ftdichip.com/EVE/EVESolutions.htm), tiene opciones de 3.5 y 5", incluyen un procesador de diseño propio, que se puede programar con el IDE de arduino, no las conozco a fondo pero parecen buenas opciones.

Mikroelektronika tambien tiene una linea de pantallas con procesador de programación incluido (http://www.mikroe.com/mikromedia-hmi/), pero los costos son algo elevados, ademas de que se programan con un entorno, por el que hay que pagar una licencia.
Muchas gracias, el vídeo que pones es exactamente la idea que tengo en la cabeza, lo malo es que quería que el proyecto saliera lo mas económico posible, por eso quería a aprovechar el Uno y las pantallas esas con el chip FTXXX no parecen nada baratas, aparte que me obligan a cambiar de Arduino.

Por lo que veo me va a tocar estrujarme un poco la cabeza y meter esas funciones en el display de siete segmentos y 8 elementos TM1638 que ya tengo.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Dec 28, 2016, 01:25 am
Muchas gracias, el vídeo que pones es exactamente la idea que tengo en la cabeza, lo malo es que quería que el proyecto saliera lo mas económico posible, por eso quería a aprovechar el Uno y las pantallas esas con el chip FTXXX no parecen nada baratas, aparte que me obligan a cambiar de Arduino.

Por lo que veo me va a tocar estrujarme un poco la cabeza y meter esas funciones en el display de siete segmentos y 8 elementos TM1638 que ya tengo.
En el hilo (Tema) como bien el autor del mismo es decir TFTLCDCyg dice "Algunos consejos..." y esta es la razón  del mismo.

No es obligar por favor a cambiar de Arduino, ustedes lo saben por lo que realicen, sin embargo mi consejo esta en repasar todo el contenido del mismo tema de estas 10 paginas (y aumentado) mi consejo es que lean estos enlaces y vayan ahorrando unos centimillos y a la larga y/o corta lo agradecerán.

LIbrería para FT8xx (https://forum.arduino.cc/index.php?topic=419836.0)

Pantallas FT8xx de HOTMCU.com (https://forum.arduino.cc/index.php?topic=406170.0)

Y por ultimo falta el enlace de una documentación del cual ya tengo prácticamente terminado sobre estas pantallas de "bajo coste" de HotMCU.com, a lo cual, si leen estas lineas "algunos" hemos realizado inversiones económicas "medianas" o grandes dependiendo del punto que se mire, para que las tengan funcionando desde el primer día. Y solo digo que todo el esfuerzo ha salido de nuestras costillas, los billetes, la compra etc... al menos en lo que respecta, todo de mi bolsillo y otros usuarios lo mismo... y me parece que existe hasta un soporte... si?

Saludos.

Title: Re: Algunos consejos para usar TFT´s
Post by: bubu_54 on Dec 29, 2016, 10:35 am
Muchas gracias a ambos, estaré atento a este hilo para ir siguiendo esas pantallas, de momento voy a exprimir el hardware que ya tengo.
Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Dec 31, 2016, 11:04 am
No me contestan. Supongo que es por entrometerme en su conversación, chicos les pido disculpas, abriré un nuevo post con mis dudas.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 31, 2016, 07:06 pm
No es por no contestar, solo que a veces solo hay tiempo para dar salida a una respuesta y luego de unos días vemos que hay mas preguntas que no hemos contestado XD.

Gracias TFTLCDCyg probare desde Windows.

Estoy teniendo problemas para usar una imagen .bmp desde la SD con ili9341_due Cambie a esta librería porque me lo aconsejaste y la verdad es que he aprendido mucho.

Con la SD tengo mis dudas ¿Que formato le doy fat32? Uso una de las pantallas que tu tienes una qvga 2.2 tft spi 320x240
¿Tengo que conectar los 4 pines de la parte j4? Para usar la SD

Otra cosa que me encanta de tus post son los medidores "gauge" y termómetros que haces.
Respecto tu duda, el lector SD de las pantallas 2.2, 2.4 y 2.8 con el chip ILI9341, se conecta usando el cabezal independiente de 4 pines:

Code: [Select]
SD-CD
SD-MOSI
SD-MISO
SD-SCK


VCC y GND están conectados a la alimentación principal del TFT

Ese lector he notado que falla frecuentemente, no sé si haga falta algún componente extra (resistencia, capacitor, etc).

Recomiendo usar un lector externo, puede ser uno de los clasicos de catalex o bien uno de 3.3V:

(http://www.mediafire.com/convkey/c7f9/1n87j8740e1g0y5zg.jpg)

(http://www.mediafire.com/convkey/85a2/7jxn9otl7t6qu6jzg.jpg)

Usa la librería SD o la SDFat para verificar que has instalado correctamente el lector SD. Procura usar cableado corto (máx 15 cms de largo).

(http://www.mediafire.com/convkey/6686/fcis14uf2r12f51zg.jpg)

Te recomiendo tarjetas micro SD de Kigston, de 4 u 8 Gb. Para formatear la tarjeta te recomiendo el programa SDFormatter V4.0 (https://www.sdcard.org/downloads/formatter_4/), con settings en default
Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Jan 01, 2017, 07:36 pm
Muchas gracias por la respuesta TFTLCDCyg voy a probar, el lector lo tengo aunque me gustaría usar el de la pantalla.

La MicroSD es una Sandisk 4GB MicroSD-HC no tengo otra para probar.
 
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jan 01, 2017, 08:20 pm
Lo prometido era una deuda muy grande para mi.

Ya esta disponible un documento mio sobre las pantallas con driver FT8xx, y no hay escusa para ir ahorrando unos centimillos y sean propietarios de estas grandísimas pantallas.

Service Manual 1.0 by lightcalamar (https://forum.arduino.cc/index.php?topic=445405.0)

Saludos!
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 03, 2017, 09:51 am
Con manual y todo, si que te has mandado algunas desveladas extra, gracias por compartir tu trabajo.

No me quito de la cabeza construirme un radio, sin embargo tengo algunos planes extra para este nuevo calendario XD.

Guardé algunos meses en el cajón los artilugios construidos para el Due y el teensy 3.2, ahora que estoy a unos meses de mudarme nuevamente de casa, traté de reusarlos y menuda sorpresa me he topado: las memorias micro SD han estado cayendo una a una XD. No se pueden formatear mas. Posiblemente las primeras pruebas las dejaron algo dañadas y no han soportado las jornadas de estress a las que las sometí.

Luego de optar por desmontar todos los artilugios que ya no ocupo, me vienen a la mente dos reflexiones con el tema del lector SD:

- No está demás sugerir que todo el avance que guardemos en la microSD, lo respaldemos de cuando en cuando en la PC, eso ha salvado hoy la jornada de experimentos XD.

- Los ejemplos CardInfo de la libreria SD, y el ejemplo SdInfo de la librería SDFat, permiten saber si el lector que estamos usando para la pantalla FT8XX está bien conectado.

Ya resolví el rompecabezas con las gráficas lineales continuas, así que en cuanto disponga de un tiempo libre me aplicaré con ese tipo de ejemplos.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jan 03, 2017, 11:02 am
Palabras muy sabias amigo!

El año pasado, con el contacto de pantallas FT8xx ha sido para mi un reto personal. Creo que he aprendido a pasos agigantados, no solo la estructura de programación en éstas, sino que se hace de otra forma a las convencionales de otras.

Tengo que agradecer a todos los que me ayudaron en códigos para "mis manías",  códigos  con los cuales voy adaptando a estas maravillosas FT8xx. Un año pasado para recordar, con todas las dificultades así como las alegrías de verlas en funcionamiento. Leyéndote desde el principio ya no desde este hilo, otros muchos, no me arrepiento el coste del mismo, las horas, el dinero invertido, etc. Muchos no sepan de lo que escribo,, sin embargo el tiempo dirá lo acertado que fuiste es dar tantos consejos.

Voy de momento a reorganizar el nuevo proyecto de mi MDC y exponer en unos días su funcionamiento del mismo. Sobre las SD tango en preparación algunos consejos del cual, y cruzo los dedos no se han estropeado ninguna que usé de pruebas. Suerte?. Ya empezado el año, quiero ser el propietario de una Teensy por su potencial, este sera otro reto sabiendo a ciencia cierta que la quiero usar para una pantalla FT810 (recientemente he pedido).

Saludos!
Title: Re: Algunos consejos para usar TFT´s
Post by: hiddenotebook on Jan 07, 2017, 11:24 am
Pues tenias toda la razón es cosa del lector de tarjetas de la pantalla con uno externo funciona bien...

(https://c1.staticflickr.com/1/638/32120188536_585c5a7037_o.jpg)

Ahora si puedes decirme como cargar una imagen fuera del sketch de ejemplo que es enorme me haces un gran favor. Porque con la librería de este chico el carga las imágenes en un formato que no es .bmp y tampoco se usar sus herramientas, yo supongo que sera meter la foto en el directorio de las herramientas y lanzar el .exe no?

voy a seguir con las pruebas. Muchas gracias por tu ayuda si no me dices lo del lector externo aun seguiría dándole vueltas.
Title: Re: Algunos consejos para usar TFT´s
Post by: Jcamilo on Feb 14, 2017, 11:40 am
Hola, Buenos dias!

Tengo en la universidad una materia en la cual debo programar el control de calentamiento del agua en un tanque, controlar el nivel del tanque y una bomba para el suministro de agua, el profesor quiere que lo hagamos con arduino y quiere que tenga una pantalla tactil donde se puedan ver los datos y se puedan cambiar los parametros de funcionamiento.
Nosotros disponemos de un Arduino Due y soy nuevo en el uso de pantallas tactiles, he leido varios Foros, pero en realidad no se por donde empezara buscar, se requiere que la pantalla sea lo mas grande posible aunque no mas de 10" y no se como saber si alguna pantalla que encuentre en el mercado podria conectarla en mi Arduino, si tienen tal vez informacion que pudiera leer o si me pueden orientar de alguna forma lo agradeceria.
Soy nuevo tambien en el mundo de los foros, no se si puedo postear esto aca o deberia crear un nuevo foro
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Feb 14, 2017, 09:18 pm
Si quieres una pantalla en condiciones una de HotMCU (http://hotmcu.com),  5 pulgadas. Si la quieres más grande enRiverdi (http://riverdi.com) eso sí que sea con chip FT8XX Son un poco caras pero .... hay soporte al menos en este foro, si no lo encuentras te pondremos los enlaces, todo lo demás es arriesgarse a que no funcione y además cientos de muchos cientos de horas de estudio.
Title: Re: Algunos consejos para usar TFT´s
Post by: Jcamilo on Feb 15, 2017, 11:15 am
Agradezco mucho la ayuda prestada, las pantallas estan geniales y tu proyecto tambien esta increible, lo estuve leyendo un poco, aunque hay muchas cosas que aun estan fuera de mis conocimientos.

Hable con el profesor y le mostre las opciones de pantalla y le gustaron, aunque el precio no.
Nos planteo otra pregunta,"sera posible utilizar una tablet conectandola por USB o algun otro tipo de conexion? debido a que se pueden encontrar Tablets mas baratas que las pantallas"
He estado leyendo al respecto y he encontrado que se podria hacer esta conexion mediante un App o la programacion de una pagina Web en el Arduino, aun no se si entendi bien, pero creo que cualquiera de las dos opciones requiere una conexion a Internet.

Existe tal vez la posibilidad de realizar esto sin una conexion a internet?
Nuevamente muchas gracias por la ayuda y espero haberme hecho entender.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 15, 2017, 07:50 pm
Existe esa posibilidad, te sugiero revisar ejemplos en la video-red, este es un buen ejemplo:

Control de leds con smartphone y aurduino (https://www.youtube.com/watch?v=d0cenuay634)

Es posible usar tablets también, ese tipo de proyectos están alejados de este hilo. Si abres un nuevo hilo con tu consulta específica, estoy seguro que recibirás apoyo de la comunidad, pero antes te invito a leer e investigar en "San google".

Algo que debes considerar es que en principio debes esforzarte, en el foro damos uno que otro consejo. A modo personal te comento que no me gusta resolver tareas ni proyectos de escuela, la razón: al estar en formación debes moldear tu propio criterio y no depender de los demás para conseguir un punto de calificación, debe ser solo tuya, ese valor te dará herramientas para salir adelante no solo en el proyecto, sino en tu vida.

PD: sino mira lo que nos pasa con "señores presidentes" que les hicieron la tarea cuando pekes y siguen "bulleando a medio mundo"...
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Feb 16, 2017, 05:03 am
Existen pantallas para arduino de 10", este es un ejemplo:http://www.buydisplay.com/default/serial-spi-arduino-10-1-tft-lcd-touch-shield-ra8876-for-mega-due-uno (http://www.buydisplay.com/default/serial-spi-arduino-10-1-tft-lcd-touch-shield-ra8876-for-mega-due-uno)

Quizás los costos sean algo mas accesibles con esa pantalla, pero no incluye el arduino Due.

La combinación teensy 3.5 + HotMCU FT810 tiene mejores precios y sin lugar a dudas, un poder gráfico muy superior al de la combinacón ra8876 + arduino Due

La siguiente combinación sería: teensy 3.6 + Riverdi FT813 5" + breakout-20

El tope para arduino sería: teensy 3.6 + Riverdi FT813 7" + breakout-20

PD: para arduino existen otras opciones, bastante fuertes por ejemplo: 4DSystems o SmartGPU2
Title: Re: Algunos consejos para usar TFT´s
Post by: Jcamilo on Feb 20, 2017, 08:51 am
Nuevamente Muchas gracias por la ayuda prestada, hay muy buenas opciones, seguire investigando
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Apr 13, 2017, 12:48 am
Pues tenias toda la razón es cosa del lector de tarjetas de la pantalla con uno externo funciona bien...

(https://c1.staticflickr.com/1/638/32120188536_585c5a7037_o.jpg)

Ahora si puedes decirme como cargar una imagen fuera del sketch de ejemplo que es enorme me haces un gran favor. Porque con la librería de este chico el carga las imágenes en un formato que no es .bmp y tampoco se usar sus herramientas, yo supongo que sera meter la foto en el directorio de las herramientas y lanzar el .exe no?

voy a seguir con las pruebas. Muchas gracias por tu ayuda si no me dices lo del lector externo aun seguiría dándole vueltas.
Perdona la tardanza, pero no había leído a detalle el post, por estar liado con GD3.

Ciertamente, usa el formato *.565, se crean con una herramienta que se maneja mediante linea de comandos desde cmd.exe en windows.

Te sugiero darle una mirada al post en el que MarekB nos ha compartido su proyecto con este tipo de pantallas: http://forum.arduino.cc/index.php?topic=265806.0 (http://forum.arduino.cc/index.php?topic=265806.0)

PD: he dejado de usar esa herramienta un buen rato y no tengo fresco el procedimiento. En cuanto me sea posible subo un ejemplo de uso.
Title: Re: Algunos consejos para usar TFT´s
Post by: Xabicarba on Jun 12, 2017, 01:37 pm
Buenas, soy novato en esto de las pantallas tft. Me compré una pantalla de 4,3 pulgadas y el modelo 4DLCD-FT843 y no consigo ponerla en marcha. Simplemente quiero hacer un menu para indicarle a un motor a la velocidad que debe ir y que lo monitorice. Pero no consigo inicializarla, no se si estoy haciendo algo mal, no consigo enviarle los comandos host al ft800 desde mi arduino.

Si me podeís ofrecer algún tipo de información que me pueda servir de ayuda lo agradecería, gracias.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 12, 2017, 02:46 pm
Antes que nada, debes indicar cómo estas conectando tu FT843 y que placa arduino quieres usar.

Interfaces

La pantalla FT843 necesita de un adaptador para funcionar en arduino, puede ser alguna de las siguientes opciones:

- ADAM (4D Systems)
- Break out para FT843 (4D Systems)
- Algún adaptador para cable plano de 10 hilos.

La ventaja del ADAM, es que incluye un lector micro SD y que puede funcionar con lógica de 5V y de 3.3V con tan solo mover un jumper; en los otros dos casos hay que construir o conseguir un lector SD externo de 3.3V.

Las conexiones son bastante simples, pero debes recordar que es un dispositivo de 3.3V, por lo que si lo conectas en arduino UNO o MEGA tienes que usar un conversor de voltaje 5V a 3.3V, si lo conectas de forma directa con el breakout no va a funcionar.

En placas como el arduino Due, teensy 3.2, teensy 3.5, o teensy 3.6, puedes conectar directamente la pantalla, ya que todas ellas son de 3.3V. Incluso podrías usar alguna versión de arduino UNO o Pro de 3.3V.

Librerías

La librería que recomienda el fabricante, está basada en la librería original de FTDI, también puedes usar la librería para el gameduino 2, también puedes usar la librería que hemos adaptado para las pantallas FT81X, en específico la versión GD23L (http://www.mediafire.com/file/h65f6c6bwp19caw/GD23L+flotantes.rar)
Title: Re: Algunos consejos para usar TFT´s
Post by: Xabicarba on Jun 12, 2017, 04:36 pm
Buenas,

Tengo la pantalla conectada con  el adaptador ADAM.
El problema es que no se que clase de lectura me hace, ni como funciona realmente.

Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 12, 2017, 07:18 pm
¿Que placa arduino estás usando?

Sube una foto del ADAM tal como lo tienes instalado, para ver como están ubicados los jumpers, es muy importante para poder orientarte mejor y saber como está configurado. Sin esta parte no podremos avanzar con la ayuda.
Title: Re: Algunos consejos para usar TFT´s
Post by: Xabicarba on Jun 13, 2017, 09:28 am
https://drive.google.com/file/d/0B5XxjzDhC8D4azB2a3QtdFB4ZzA/view?usp=sharing (https://drive.google.com/file/d/0B5XxjzDhC8D4azB2a3QtdFB4ZzA/view?usp=sharing)

Estoy utilizando la placa de arduino uno.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 13, 2017, 09:26 pm
Aunque la placa arduino UNO sirve, te sugiero que en cuanto puedas consigas un MEGA o un Due. Estas pantallas funcionan con limitaciones de tamaño de sketch (en algunos casos de velocidad) en placas como el arduino UNO, Pro o mini.

Si aun así la quieres usar, mas vale que vayas estudiando a fondo el lenguaje de arduino, para que tus códigos sean lo mas optimizado posible. Pero siempre tendrás limitaciones de memoria de programación

Por lo que veo el shield está configurado a 5V.

Code: [Select]
SCS       10        (chip select del lector micro SD)
DCS        9        (chip select del TFT)
PD         8
INT        7


El cableado adicional es MOSI, MISO, SCK y GND.

Algunos comentarios respecto a la librería FTDI para pantallas FT80X

INT y PD, son pines de interrupción que usa la librería original (y variantes) de FTDI. Aunque en algunas pruebas que he podido hacer con ella, pueden ser omitidos, definiendo el pin de conexión como 0

Puedes manipular los pines SCS y DCS, conectándolos a cualquier pin digital de tu placa preferida. En el caso del ADAM, ya están fijados, solo debes asegurarte que estén bien definidos en la librería que decidas usar.

Una cosa más, el IDE de arduino compatible con las librerías originales de FTDI es el 1.5.6-R2, los IDE´s `posteriores no sirven.

Librería sugerida

Para que puedas conectar tu FT843 a tu MCU preferido y en cualquier IDE de arduino, te recomiendo la librería para gameduino 2 modificada para el shield FT843 de 4DSystems o el shield de Riverdi (http://www.mediafire.com/file/vuht0q1vx03m6hq/Gameduino2.rar)

Solo tienes que modificar dos definiciones de pines en el archivo GMD2.h

Por default estan asignados para el shield de Riverdi:

Code: [Select]
//Definir pines de control

  #define CS_PIN   10  //10 Riverdi shield   9   ADAM-FT843
  #define SD_PIN   5   // 5 Riverdi shield  10   ADAM-FT843


De acuerdo con la foto que subiste, para que funcione con el ADAM, tendría que quedar así:

Code: [Select]
//Definir pines de control

  #define CS_PIN   9   //10 Riverdi shield   9   ADAM-FT843
  #define SD_PIN   10   // 5 Riverdi shield  10   ADAM-FT843


Retira los jumpers en PD e INT.
Title: Re: Algunos consejos para usar TFT´s
Post by: Xabicarba on Jun 14, 2017, 09:23 am
Muchas gracias, seguro que me es de gran ayuda!!
Title: Re: Algunos consejos para usar TFT´s
Post by: ansclaudio3 on Sep 27, 2017, 07:14 pm
Hola, se puede hacer un dashboard con una tft de 5 pulgadas que hay en mercadolibre? Es para un auto de rally.
Title: Re: Algunos consejos para usar TFT´s
Post by: daniboy93 on Nov 18, 2017, 12:23 am
Hola buen día a todos, tengo una TFT  que quiero utilizar en un proyecto. la adquirí en ebay dejo el link:

3-5-inch-TFT-LCD-Resistive-Touch-Shield-for-Arduino-Due-MEGA-2560-w-Library (https://www.ebay.com/itm/3-5-inch-TFT-LCD-Resistive-Touch-Shield-for-Arduino-Due-MEGA-2560-w-Library/302072836005?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2057872.m2749.l2649)


estaba intentando cargar el código de prueba de la librería que esta en la pagina, y no me lo permitía, hasta que desconecte la TFT con su shield,  cargue el programa en mi Mega 2560 y mi sorpresa funcionó, pero al querer modificar el código y cargarlo no me permite cargar a menos que desconecte  el shield. intente ya utilizar adaptador externo,  inclusive para evitar la alimentación de bajo amperaje doblar el pin de 3.3v  y nada.

alguna idea  de cual pueda ser el problema ??   dejo el código de prueba (es un teclado numerico)  para que corroboren que esta correcto.   creo que es mas un problema de alimentación o interferencia al cargar el código

Code: [Select]

/***************************************************
// Web: http://www.buydisplay.com
EastRising Technology Co.,LTD
Examples for ER-TFTM035-6 with Resistive Touch Panel
Software SPI/8080 16-bit Parallel Interface 3.3V Power Supply
****************************************************/

#include <UTFT.h>
#include <UTouch.h>

// parallel 8080 16BIT
// Initialize display
// Library only supports software SPI at this time
//Arduino DUE,Arduino mega2560
UTFT myGLCD(ILI9488_16,7,38,9,10);    //(byte model, int RS, int WR, int CS, int RST, int SER)
UTouch  myTouch( 2, 6, 3, 4, 5);      //RTP: byte tclk, byte tcs, byte din, byte dout, byte irq

// Declare which fonts we will be using
extern uint8_t BigFont[];

int x, y;
char stCurrent[20]="";
int stCurrentLen=0;
char stLast[20]="";

/*************************
**   Custom functions   **
*************************/

void drawButtons()
{
// Draw the upper row of buttons
  for (x=0; x<5; x++)
  {
    myGLCD.setColor(0, 0, 255);
    myGLCD.fillRoundRect (10+(x*60), 10, 60+(x*60), 60);
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRoundRect (10+(x*60), 10, 60+(x*60), 60);
    myGLCD.printNumI(x+1, 27+(x*60), 27);
  }
// Draw the center row of buttons
  for (x=0; x<5; x++)
  {
    myGLCD.setColor(0, 0, 255);
    myGLCD.fillRoundRect (10+(x*60), 70, 60+(x*60), 120);
    myGLCD.setColor(255, 255, 255);
    myGLCD.drawRoundRect (10+(x*60), 70, 60+(x*60), 120);
    if (x<4)
      myGLCD.printNumI(x+6, 27+(x*60), 87);
  }
  myGLCD.print("0", 267, 87);
// Draw the lower row of buttons
  myGLCD.setColor(0, 0, 255);
  myGLCD.fillRoundRect (10, 130, 150, 180);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect (10, 130, 150, 180);
  myGLCD.print("Clear", 40, 147);
  myGLCD.setColor(0, 0, 255);
  myGLCD.fillRoundRect (160, 130, 300, 180);
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect (160, 130, 300, 180);
  myGLCD.print("Enter", 190, 147);
  myGLCD.setBackColor (0, 0, 0);
}

void updateStr(int val)
{
  if (stCurrentLen<20)
  {
    stCurrent[stCurrentLen]=val;
    stCurrent[stCurrentLen+1]='\0';
    stCurrentLen++;
    myGLCD.setColor(0, 255, 0);
    myGLCD.print(stCurrent, LEFT, 224);
  }
  else
  {
    myGLCD.setColor(255, 0, 0);
    myGLCD.print("BUFFER FULL!", CENTER, 192);
    delay(500);
    myGLCD.print("            ", CENTER, 192);
    delay(500);
    myGLCD.print("BUFFER FULL!", CENTER, 192);
    delay(500);
    myGLCD.print("            ", CENTER, 192);
    myGLCD.setColor(0, 255, 0);
  }
}

// Draw a red frame while a button is touched
void waitForIt(int x1, int y1, int x2, int y2)
{
  myGLCD.setColor(255, 0, 0);
  myGLCD.drawRoundRect (x1, y1, x2, y2);
  while (myTouch.dataAvailable())
    myTouch.read();
  myGLCD.setColor(255, 255, 255);
  myGLCD.drawRoundRect (x1, y1, x2, y2);
}

/*************************
**  Required functions  **
*************************/

void setup()
{// The following two lines are needed for the  display
// module to enable the backlight. If you are using any other
// display module these lines should be commented out.
// -------------------------------------------------------------
//  pinMode(41, OUTPUT);
//  digitalWrite(41, HIGH);
// -------------------------------------------------------------
// Initial setup
  myGLCD.InitLCD();
  myGLCD.clrScr();

  myTouch.InitTouch();
  myTouch.setPrecision(PREC_MEDIUM);

  myGLCD.setFont(BigFont);
  myGLCD.setBackColor(0, 0, 255);
  drawButtons();  
}

void loop()
{
  while (true)
  {
    if (myTouch.dataAvailable())
    {
      myTouch.read();
      x=myTouch.getX();
      y=myTouch.getY();
      
      if ((y>=10) && (y<=60))  // Upper row
      {
        if ((x>=10) && (x<=60))  // Button: 1
        {
          waitForIt(10, 10, 60, 60);
          updateStr('1');
        }
        if ((x>=70) && (x<=120))  // Button: 2
        {
          waitForIt(70, 10, 120, 60);
          updateStr('2');
        }
        if ((x>=130) && (x<=180))  // Button: 3
        {
          waitForIt(130, 10, 180, 60);
          updateStr('3');
        }
        if ((x>=190) && (x<=240))  // Button: 4
        {
          waitForIt(190, 10, 240, 60);
          updateStr('4');
        }
        if ((x>=250) && (x<=300))  // Button: 5
        {
          waitForIt(250, 10, 300, 60);
          updateStr('5');
        }
      }

      if ((y>=70) && (y<=120))  // Center row
      {
        if ((x>=10) && (x<=60))  // Button: 6
        {
          waitForIt(10, 70, 60, 120);
          updateStr('6');
        }
        if ((x>=70) && (x<=120))  // Button: 7
        {
          waitForIt(70, 70, 120, 120);
          updateStr('7');
        }
        if ((x>=130) && (x<=180))  // Button: 8
        {
          waitForIt(130, 70, 180, 120);
          updateStr('8');
        }
        if ((x>=190) && (x<=240))  // Button: 9
        {
          waitForIt(190, 70, 240, 120);
          updateStr('9');
        }
        if ((x>=250) && (x<=300))  // Button: 0
        {
          waitForIt(250, 70, 300, 120);
          updateStr('0');
        }
      }

      if ((y>=130) && (y<=180))  // Upper row
      {
        if ((x>=10) && (x<=150))  // Button: Clear
        {
          waitForIt(10, 130, 150, 180);
          stCurrent[0]='\0';
          stCurrentLen=0;
          myGLCD.setColor(0, 0, 0);
          myGLCD.fillRect(0, 224, 319, 239);
        }
        if ((x>=160) && (x<=300))  // Button: Enter
        {
          waitForIt(160, 130, 300, 180);
          if (stCurrentLen>0)
          {
            for (x=0; x<stCurrentLen+1; x++)
            {
              stLast[x]=stCurrent[x];
            }
            stCurrent[0]='\0';
            stCurrentLen=0;
            myGLCD.setColor(0, 0, 0);
            myGLCD.fillRect(0, 208, 319, 239);
            myGLCD.setColor(0, 255, 0);
            myGLCD.print(stLast, LEFT, 208);
          }
          else
          {
            myGLCD.setColor(255, 0, 0);
            myGLCD.print("BUFFER EMPTY", CENTER, 192);
            delay(500);
            myGLCD.print("            ", CENTER, 192);
            delay(500);
            myGLCD.print("BUFFER EMPTY", CENTER, 192);
            delay(500);
            myGLCD.print("            ", CENTER, 192);
            myGLCD.setColor(0, 255, 0);
          }
        }
      }
    }
  }
}
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Nov 18, 2017, 09:10 pm
No parece un tema de librerías, pero quizás puedas intentarlo, me da que es un tema de fallo físico.

Mi recomendación es que contactes al vendedor. En segundo lugar intenta usando la librería oficial del fabricante:

http://www.buydisplay.com/default/arduino-3-5-tft-lcd-touch-shield-serial-spi-example-for-mega-due (http://www.buydisplay.com/default/arduino-3-5-tft-lcd-touch-shield-serial-spi-example-for-mega-due)

Ese comportamiento es posible que tenga que ver con la configuración del shield, en la página del fabricante está disponible la documentación.

Quizás alguno (o algunos) de los pines del shield no está haciendo buen contacto con la placa arduino, verifica que no haya alguno doblado y trata de alinearlos lo más posible.

Eso lo estoy experimentando ahora en el proyecto en curso con una STM32F746IG (Core7XXI),  un solo hilo que falle en el contacto, basta para hacer fallar a todo el arreglo...

(http://www.mediafire.com/convkey/cff7/2hmocwn20vtkfkjzg.jpg)

He notado que los headers de las placas arduino, últimamente son muy débiles, sobre todo en las placas clones. En este caso solo queda cambiarlos por headers nuevos, todo un lío.

Es una pena pensé que esos TFT tendrían mejores estándares de calidad.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Dec 12, 2017, 09:22 am
Luego de un tiempo va reduciéndose la carga de urgentes en el trabajo y permite espacio para retomar los hobbies.

Hace un tiempo he estado tratando de entender como es que se puede hacer funcionar la librería para gameduino 2 en placas STM32. Parece que los progresos en el equipo FT81xmania nos han ocupado con mas tiempo aún. Viene un cisma con el inminente arribo del shield oficial gameduino 3, así como la librería oficial respectiva, que llevará al límite las capacidades de las pantallas FT8XX.

ILI9341 en ESP32

Con el arribo de las placas ESP32, también le he dedicado un tiempo a entender como funciona el bus SPI en ellas, poco a poco van saliendo a la luz las librerías porteadas desde librerías conocidas, y con las que ya estamos familiarizados en el entorno arduino, teensy o STM32.

Uno de los chips controladores de pantallas es el ILI9341; conservo aún varias pantallas SPI con este controlador y decidí darle una oportunidad más, para poder hacerlo funcionar en placas ESP32, en específico en la placa ESP32 Dev Module o DOIT ESP32 DEVKIT V1.

La mejor librería que podemos usar es esta TFT_eSPI (https://forum.arduino.cc/index.php?topic=443787.msg3145402#msg3145402), desarrolada y soportada por un forero frecuente: bodmer

(http://www.mediafire.com/convkey/9c36/aajwdiqf1ljmdjqzg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 02, 2018, 12:06 pm
Buenos días,

Soy algo nuevo en esto de las pantallas TFT. He comprando un a pantalla de 4D SYSTEMS FT843 con ADAM. Cargue la libreria de GAMEDUINO2 y funciona bastante bien, pero lo que veo es que el tactil no esta calibrado, en los ejemplos, no responde a la zona en donde tocas. ¿a que puede ser debido? hay alguna forma de calibrarla?

Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 04, 2018, 05:48 am
¿Qué MCU estas usando?

Por allí podemos partir para averiguar qué está pasando. La combinación FT843+ADAM es bastante noble
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 04, 2018, 06:56 pm
Para hacer unas pruebas estoy usando Arduino UNO, pero para el proyecto final tengo un Mega. Ya he conseguido calibrarla, lo había hecho mal desde el principio.

Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 04, 2018, 07:04 pm

Tengo otro pequeño problemilla, por si me puedes ayudar. Quiero mediante pulsadores digitales encender unos reles, estoy haciendo unas pruebas para encender unos led. El primer led me lo enciende y me lo apaga bien, pero en el otro pulsador no me funciona. Me podrías ayudar con el código.

EL CÓDIGO QUE ESTOY USANDO ES EL SIGUIENTE.
Code: [Select]


#include <EEPROM.h>
#include <SPI.h>
#include <GMD2.h>

int a = 0;
int led = 8;
int led1 = 7;

void setup()
{
pinMode(led,OUTPUT);
pinMode(led1,OUTPUT);
Serial.begin (9600);
GD.begin(0);
//  GD.Clear();
GD.begin(RECTS);

}

void loop()
{

GD.cmd_gradient(0,0, 0x0060c0,0, 271, 0x06000);

GD.cmd_text( 240, 12, 29, OPT_CENTER, "CONTROL ENCENDIDO APARATOS");
GD.PointSize(16*30);
GD.Begin(POINTS);
GD.ColorA(128);
GD.ColorRGB(0xff8000);
GD.Tag(100);
GD.Vertex2ii(220,50);
GD.ColorRGB(0x0080ff);
//GD.Tag(255);
GD.Tag(101);
GD.Vertex2ii(260,170);
GD.ColorRGB(0x000000);
GD.cmd_text( 260, 170, 31, OPT_CENTER, "2");
//GD.Tag(255);
//GD.LineWidth(10*16); /// curvatura de las esquinas cuadrado
GD.Begin(RECTS);
GD.ColorRGB(0xC5C7F4);
GD.Tag(102);
GD.Vertex2ii(400,80); // X-inixio Y-inicio
GD.Vertex2ii(350, 130); // X-final Y-final


GD.swap();


GD.get_inputs();
Serial.println(GD.inputs.tag);

if (GD.inputs.tag==101){
        delay(195);
       if (a==0){
                           
        Serial.println("led apagado");
      digitalWrite(led,LOW);
      a = 1;
        delay(500);
        }
        else if (a==1){
        Serial.println("led encendido");
        digitalWrite(led,HIGH);          
       a = 0;
        delay (500);
        }

if (GD.inputs.tag==102){
        delay(195);
       if (a==0){
                           
        Serial.println("led apagado");
      digitalWrite(led1,LOW);
      a = 1;
        delay(500);
        }
        else if (a==1){
        Serial.println("led encendido");
        digitalWrite(led1,HIGH);          
       a = 0;
        delay (500);
        }


Gracias

       
   
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 07, 2018, 04:38 am
Tengo otro pequeño problemilla, por si me puedes ayudar. Quiero mediante pulsadores digitales encender unos reles, estoy haciendo unas pruebas para encender unos led. El primer led me lo enciende y me lo apaga bien, pero en el otro pulsador no me funciona. Me podrías ayudar con el código.

EL CÓDIGO QUE ESTOY USANDO ES EL SIGUIENTE.
Code: [Select]


#include <EEPROM.h>
#include <SPI.h>
#include <GMD2.h>

int a = 0;
int led = 8;
int led1 = 7;

void setup()
{
pinMode(led,OUTPUT);
pinMode(led1,OUTPUT);
Serial.begin (9600);
GD.begin(0);
//  GD.Clear();
GD.begin(RECTS);

}

void loop()
{

GD.cmd_gradient(0,0, 0x0060c0,0, 271, 0x06000);

GD.cmd_text( 240, 12, 29, OPT_CENTER, "CONTROL ENCENDIDO APARATOS");
GD.PointSize(16*30);
GD.Begin(POINTS);
GD.ColorA(128);
GD.ColorRGB(0xff8000);
GD.Tag(100);
GD.Vertex2ii(220,50);
GD.ColorRGB(0x0080ff);
//GD.Tag(255);
GD.Tag(101);
GD.Vertex2ii(260,170);
GD.ColorRGB(0x000000);
GD.cmd_text( 260, 170, 31, OPT_CENTER, "2");
//GD.Tag(255);
//GD.LineWidth(10*16); /// curvatura de las esquinas cuadrado
GD.Begin(RECTS);
GD.ColorRGB(0xC5C7F4);
GD.Tag(102);
GD.Vertex2ii(400,80); // X-inixio Y-inicio
GD.Vertex2ii(350, 130); // X-final Y-final


GD.swap();


GD.get_inputs();
Serial.println(GD.inputs.tag);

if (GD.inputs.tag==101){
        delay(195);
       if (a==0){
                          
        Serial.println("led apagado");
      digitalWrite(led,LOW);
      a = 1;
        delay(500);
        }
        else if (a==1){
        Serial.println("led encendido");
        digitalWrite(led,HIGH);          
       a = 0;
        delay (500);
        }

if (GD.inputs.tag==102){
        delay(195);
       if (a==0){
                          
        Serial.println("led apagado");
      digitalWrite(led1,LOW);
      a = 1;
        delay(500);
        }
        else if (a==1){
        Serial.println("led encendido");
        digitalWrite(led1,HIGH);          
       a = 0;
        delay (500);
        }


Gracias

      
  

La programación de estas pantallas es diferente a lo que has podido usar hasta antes de tu FT843. Hay que adaptarse al sistema de refresco que tiene el chip controlador.

Si usas la programación habitual la pantalla no responderá.

Code: [Select]
#include <EEPROM.h>
#include <SPI.h>
#include <GMD2.h>

int a, b;

void setup()
{
   GD.begin();
   MP();
}
void loop(){}

void MP()
{
 while(1){
 GD.get_inputs();
 GD.Clear();
 GD.cmd_gradient(0,0, 0x0060c0,0, GD.h/1.5, 0x06000);
 
 GD.cmd_text( GD.w/2, 12, 29, OPT_CENTER, "CONTROL ENCENDIDO APARATOS");
  
 
  GD.Begin(POINTS);  GD.PointSize(16*40);    
    
  GD.RestoreContext();

  GD.SaveContext();    
  if(a==0)
    {
     GD.ColorRGB(0x550000);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*65); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*105); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0xff8000);
     GD.Tag(100); GD.Vertex2ii(220,85);
          
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 85, 31, OPT_CENTER, "Off");
     GD.Tag(255);
    }

  if(a==1)
    {
     GD.ColorRGB(0x005500);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*65); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*105); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0xff8000);
     GD.Tag(100); GD.Vertex2ii(220,85);
    
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 85, 31, OPT_CENTER, "On");
     GD.Tag(255);
    }
  GD.RestoreContext();


  GD.SaveContext();
  if(b==0)
    {
     GD.ColorRGB(0x550000);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*150); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*190); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0x0080ff);
     GD.Tag(101); GD.Vertex2ii(220,170);
          
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 170, 31, OPT_CENTER, "Off");
     GD.Tag(255);
    }

  if(b==1)
    {
     GD.ColorRGB(0x005500);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*150); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*190); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0x0080ff);
     GD.Tag(101); GD.Vertex2ii(220,170);
          
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 170, 31, OPT_CENTER, "On");
     GD.Tag(255);
    }
   GD.RestoreContext();

 if (GD.inputs.tag==100){delay(195);  a=a+1;  if(a>=2){a=0;}}
 if (GD.inputs.tag==101){delay(195);  b=b+1;  if(b>=2){b=0;}}
 
 GD.swap();
 }
}


El uso del loop principal causa algunos errores bastante difíciles de rastrear, es mejor usar un sistema de funciones independientes, de esta forma la pantalla no entra en conflictos. Dale una mirada al ejemplo anterior para que te des una idea. Tiene dos pulsadores con dos leds simulados, bastará con que ingreses los llamados de los leds que quieres controlar
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 07, 2018, 07:33 pm
En la pantalla los led simulados se enciende y apagan correctamente, solo he tenido que cambiar "GD.h/1.5" y "GD.w/2" por los valores, porque me daba error. He configurado la salida del led, pero no se enciende. ¿hay que hacer algo mas? Te dejo en código con lo que he añadido.



Code: [Select]


#include <EEPROM.h>
#include <SPI.h>
#include <GMD2.h>

int a, b;
const int ledPIN = 8;

void setup()
{
   GD.begin();
   MP();
   pinMode(ledPIN,OUTPUT);
   
   
}
void loop(){}



void MP()
{
 
 while(1){
 GD.get_inputs();
 GD.Clear();
 GD.cmd_gradient(0,0, 0x0060c0,0, 271, 0x06000);
 
 GD.cmd_text( 240, 12, 29, OPT_CENTER, "CONTROL ENCENDIDO APARATOS");
 
 
  GD.Begin(POINTS);  GD.PointSize(16*40);     
     
  GD.RestoreContext();

  GD.SaveContext();     
  if(a==0)
    {
     digitalWrite(ledPIN,LOW); ///LED PIN8 APAGADO
     GD.ColorRGB(0x550000);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*65); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*105); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0xff8000);
     GD.Tag(100); GD.Vertex2ii(220,85);
         
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 85, 31, OPT_CENTER, "Off");
     GD.Tag(255);
   
    }

  if(a==1)
    {
     digitalWrite(ledPIN,HIGH); //LED PIN8 ENCENDIDO
     GD.ColorRGB(0x005500);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*65); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*105); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0xff8000);
     GD.Tag(100); GD.Vertex2ii(220,85);
     
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 85, 31, OPT_CENTER, "On");
     GD.Tag(255);
   
    }
  GD.RestoreContext();


  GD.SaveContext();
  if(b==0)
    {
     GD.ColorRGB(0x550000);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*150); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*190); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0x0080ff);
     GD.Tag(101); GD.Vertex2ii(220,170);
         
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 170, 31, OPT_CENTER, "Off");
     GD.Tag(255);
    }

  if(b==1)
    {
     GD.ColorRGB(0x005500);
     GD.Begin(RECTS);
     GD.Vertex2f(16*350,16*150); // X-inixio Y-inicio
     GD.Vertex2f(16*400, 16*190); // X-final Y-final

     GD.Begin(POINTS);  GD.PointSize(16*40);
     GD.ColorRGB(0x0080ff);
     GD.Tag(101); GD.Vertex2ii(220,170);
         
     GD.ColorRGB(0x000000);  GD.cmd_text( 220, 170, 31, OPT_CENTER, "On");
     GD.Tag(255);
    }
   GD.RestoreContext();

 if (GD.inputs.tag==100){delay(195);  a=a+1;  if(a>=2){a=0;}}
 if (GD.inputs.tag==101){delay(195);  b=b+1;  if(b>=2){b=0;}}
 
 GD.swap();
 }
}



Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 11, 2018, 07:53 pm
Hola.
Estoy intentando que me salga la temperatura tambien en la FT843 y no sale. Uso una sonda NTC 10k, en el puerto serie si me indica la temperatura, pero en la pantalla sale algo borroso y no se ve. ¿ a que puede ser debido?
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 11, 2018, 10:23 pm
Prueba a poner el código que has usado y se te pueda ayudar.

Saludos.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 12, 2018, 06:22 am
La mezcla de códigos separados tiene que tener como base el conocimiento correcto de los componentes que quieres unir.

En el caso de los leds que quieres controlar, te sugiero revisarlos con los códigos básicos de toda la vida.

En la placa STM32 nucleo-F767ZI vienen tres leds abordo, por lo que me es posible hacer algunas pruebas solo conectando la pantalla con chip FTDI, en este caso usaré una FT813 de 5" de Newhaven display.

Primero revisaremos el comportamiento básico de cada uno de los tres leds:

Code: [Select]
int led0 = PB0;  //PB7(azul), PB0(verde), PB14(rojo)
int led1 = PB7;
int led2 = PB14;

void setup() {               
  pinMode(led0, OUTPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  MP();   
}
void loop(){}


void MP()
{
  int contador;
  while(1)
  {
    contador=contador+1;
    if(contador>=3){contador=0;}
    delay(250);
    if(contador==0){digitalWrite(led0, HIGH); digitalWrite(led1, LOW); digitalWrite(led2, LOW);}
    if(contador==1){digitalWrite(led0, LOW); digitalWrite(led1, HIGH); digitalWrite(led2, LOW);}
    if(contador==2){digitalWrite(led0, LOW); digitalWrite(led1, LOW); digitalWrite(led2, HIGH);}
  }
}


En tu caso debes usar los pines digitales de tu arduino en los que tienes conectados los leds.

El equivalente sin delay

Code: [Select]
int led0 = PB0;  //PB7(azul), PB0(verde), PB14(rojo)
int led1 = PB7;
int led2 = PB14;

long previousMillis = 0; long interval = 250;   

void setup() {               
  pinMode(led0, OUTPUT);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  MP();   
}
void loop(){}

void MP()
{
  int contador;
  while(1)
  {
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > interval)
    {
      previousMillis = currentMillis;   
     
      contador=contador+1;
      if(contador>=3){contador=0;}
     
      if(contador==0){digitalWrite(led0, HIGH); digitalWrite(led1, LOW); digitalWrite(led2, LOW);}
      if(contador==1){digitalWrite(led0, LOW); digitalWrite(led1, HIGH); digitalWrite(led2, LOW);}
      if(contador==2){digitalWrite(led0, LOW); digitalWrite(led1, LOW); digitalWrite(led2, HIGH);}
    }
  }
}


El siguiente paso es usar el código de los botones.

PD: recuerda que en estas pantallas el uso de void loop causa algunos problemas, por lo que es mejor el uso de instrucciones que permiten obtener bucles infinitos como while.
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 12, 2018, 10:27 am
El codigo que uso para la temperatura es este. En el serial si me indica bien la temperatura pero en la FT843 no me sale nada. Tampoco me sale el simbolo de °(grado) si lo pongo..hay que crear el caracter como pasa en los lcd?

Gracias

Code: [Select]

# include <EEPROM.h>
# include <SPI.h>
# include <GMD2.h>
# include <math.h><br>


void setup()

 {

GD.begin();
Serial.begin(115200);
}

Double Thermister(int RawADC){
Double Temp;
Temp = long (((10240000/RawADC)-10000));
Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp))*Temp);
Temp = Temp - 273.15; // convierte de Kelvin a Celsius

}

 

void loop()

 {

Int val;
double temp;
val=analogRead(0);
temp=Thermister(val);
Serial.println(temp);

 GD.ClearColorRGB(0x103000);
GD.Clear();
GD.cmd_text(240, 136, 31, OPT_CENTER, temp);
GD.swap();

 }

 
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jun 12, 2018, 06:34 pm
Reitero: olvidate de la programación que usas en arduino, estas pantallas no funcionan así.

Creo que deberías revisar el manual de instrucciones de la librería de gameduino: gameduino 2 cook book (http://excamera.com/files/gd2book_v0.pdf)

Estas intentando imprimir un número mediante un comando que imprime cadenas de texto

Code: [Select]
GD.cmd_text(240, 136, 31, OPT_CENTER, temp);

La función para imprimir números que viene en la librería original solo imprime enteros. En este caso, requieres que el número se muestre con decimales. Hemos incorporado en la librería la función printNfloat, que se usa de esta forma en el ejemplo que mencionas:

Code: [Select]
GD.printNfloat(240, 136, temp, 2, 31);

Code: [Select]
# include <EEPROM.h>
# include <SPI.h>
# include <GMD2.h>
# include <math.h>

void setup()
{
 GD.begin();
 Serial.begin(115200);
}

double Thermister(int RawADC){
 double Temp;
 Temp = long (((10240000/RawADC)-10000));
 Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp))*Temp);
 Temp = Temp - 273.15; // convierte de Kelvin a Celsius
}

void loop()
{
 int val;
 double temp;
 val=analogRead(0);
 temp=Thermister(val);
 Serial.println(temp);

 GD.ClearColorRGB(0x103000);
 GD.Clear();
 //GD.cmd_text(240, 136, 31, OPT_CENTER, temp);
 GD.printNfloat(240, 136, temp, 2, 31);
GD.cmd_text(305, 148, 28, OPT_CENTER, "o");

GD.swap();
}


El manejo de símbolos como el de "grado", lo consigues imprimiendo una cadena de texto adelante del número. Recuerda que es una representación gráfica y puedes usar técnicas de superposición básicas. En este caso podrías usar la letra "o" minúscula, desfasada; para representar el símbolo de grado.

La librería cuenta con una fuente en la que está almacenado el código ASCII, solo que el tamaño es algo reducido, se encuentra en la fuente tamaño 19. El símbolo de grado se consigue con esta linea:

Code: [Select]
GD.Vertex2ii(150, 350, 19, 248);
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 13, 2018, 05:34 pm
Ok. Revisare la libreria antes de nada. Me podrias mandar la aplicacion para convertir los iconos gd2asset. Me la baje en laa primeraa hojaa del foro pero le da erroe al descomprimirla.

Graciaa
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 13, 2018, 10:28 pm
He probado el código que me has puesto y en esta linea me da error, me dice  'class GDClass' has no member named 'printNfloat'

 
Code: [Select]

GD.printNfloat(240, 136, temp, 2, 31);


Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 14, 2018, 10:10 am
Te da error porque has usado la librería original.  Esta no tiene la función que te describío @TFTLCDCyg

Aquí tienes la librería Unoficial que hemos adaptado a todas las MCU ' s ; https://github.com/lightcalamar/GD23Z (https://github.com/lightcalamar/GD23Z)

Tambien encontrarás mucha información aquí; ft81xmania.com (https://ft81xmania.com/comunidad/index.php)
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 14, 2018, 12:31 pm
Gracias. Estoy empezando con las TFT y se me resisten un poco. Como me bajo la libreria?No me sale la opcion de descargar.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 14, 2018, 12:49 pm
 :o

Pues así;


(https://i.imgur.com/Q2o0zVE.jpg)

La descomprimes, led quitas el "-master" del final y la pones en C:/tu_version_arduino/libreries/
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 14, 2018, 12:53 pm
Si se que es asi, pero a mi  el boton de descarga descargar no me sale....
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 14, 2018, 12:58 pm
Ya me salio de repente. Muchas gracias!!!! Ya os ire comentando mis problemillas. Si en algun mimento molesto me lo decis.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 14, 2018, 01:02 pm
Para el soporte de la libreria, la tenemos en nuestro foro. asi como las diferentes configuraciones.

saludos.
Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 14, 2018, 07:36 pm
he descargado la librería GD23Z. He probado con el ejemplo de HELLO WORD, que esta en la carpeta all_board. Pero al compilarlo me da "error de compilado para la tarjeta arduino/genuino Uno. Uso la version de IDE 1.8.3. Es la versión correcta?

(https://forum.arduino.cc/index.php?action=dlattach;topic=346755.0;attach=262249)
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jun 19, 2018, 12:03 am
he descargado la librería GD23Z. He probado con el ejemplo de HELLO WORD, que esta en la carpeta all_board. Pero al compilarlo me da "error de compilado para la tarjeta arduino/genuino Uno. Uso la version de IDE 1.8.3. Es la versión correcta?
Esta librería funciona perfectamente.

En IDE release 1.8.3 y mejor si usas la v1.8.5 va muy fina ...

Exactamente que error te da?
Puedes poner la salida de la consola total del error?

De haberlo puesto, te hubiese contestado con tu error y no pedirtelo ahora. ...

Saludos.

Title: Re: Algunos consejos para usar TFT´s
Post by: DAVID2134 on Jun 19, 2018, 07:46 pm
He conseguido que lo compile, me faltaba la libreria Sdfat. Ya me sale el ejemplo de HELLO WORD, pero me sale al revés. me sale girada la pantalla y no me sale centrado. He configurado estos pines en la librería, que son los mismo que tenía la librería GMD2.

Code: [Select]

//Arduino UNO, MEGA, Due, Teensy32, Teensy36
 #define CS          9  // gameduino 2/3 8
#define SD_PIN       10 // gameduino 2/3 9
 //#define CS         10  // Riverdi NHD
// #define SD_PIN      5  // Riverdi NHD


Un saludo y muchas gracias por la ayuda que me estáis prestando.
Title: Re: Algunos consejos para usar TFT´s
Post by: arkarash on Jul 02, 2018, 02:48 pm
Buenas, estoy buscando un TFT táctil que no me de muchos problemas y no sea extremadamente caro y sea fácil de sustituir (he leído que en las pantallas resistivas se tienen que medir unos pines e insertarlos en el software). La idea es un simple teclado numérico otro con un aspecto curioso, que no sean los 4 botones cutres y ya. A lo mejor añadirle alguna pantalla de bienvenida de usuario y esas cosas.

Que TFT me recomendaríais? Supongo que por lo que he leído un tf81xx, alguno en particular? Con 3.5-4" va que sobra. O para lo que yo necesito con uno de los antiguos ili94xx ya es suficiente??

Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: arkarash on Jul 07, 2018, 06:32 pm
Up. Nadie me aconseja una pantalla y un shield? Es que he leído infinidad de foros y todos dicen cosas dispares. Solo necesito alguno que no se mucha faena de conexión y esté bien testeado por la comunidad no tengo tiempo de empezar a pedir pantallas a China e ir haciendo testers ya que lo necesito para septiembre.
Title: Re: Algunos consejos para usar TFT´s
Post by: surbyte on Jul 07, 2018, 09:42 pm
El hilo esta lleno de ejemplos, el foro esta plagado de recomendaciones similares, porque no bucas un poco usando tu tiempo. En este hilo el resultado son pantallas FT8XX como las mejores. Si son caras es otro tema.
Las Nextion tmb son muy interesantes.

No se puede estar pidiendo todo de arriba y luego volver para decir "Nadie me aconseja una pantalla y un shield?"

Lee todo el hilo y verás las buenas y malas opciones que estan disponibles.
Title: Re: Algunos consejos para usar TFT´s
Post by: arkarash on Jul 08, 2018, 07:55 am
Perdón si te pareció fuera de lugar, sólo quería saber para el uso que iba a darle yo que pantallas de recomendaban. Pero ya he decidido, me he comprado una nextion y probaré a ver qué tal. Mi intención no era comprarme la mejor pantalla del mercado que es de lo que hablan la mayoría de hilos, ni de pantallas súper hd con buenas velocidades si no cogerme algo bueno, bonito y barato sin llegar a llenarme de papeles. Aumente volví a postear por hacer un Up al hilo que ya había cambiado a la página 2.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jul 09, 2018, 02:56 am
Ojalá y que cuando te llegue la pantalla que has optado por usar en tus proyectos, nos des a conocer tus impresiones, ya sea en este hilo o bien en un nuevo post en el foro; ya que a mas de un forero he visto que le interesan ese tipo de pantallas.

La idea es que sea más fácil para todos programar otro tipo de pantallas, nos ayudaría bastante a conocer otras alternativas; ya que igual he menospreciado la capacidad de esos TFT.
Title: Re: Algunos consejos para usar TFT´s
Post by: arkarash on Jul 09, 2018, 08:22 am
No dudes que lo haré TFTLCDyg, tus comentarios los he leído todos pero voy a muchos años luz de tus experimentos con TFT's. Espero que para lo que yo necesito que es muuuuy simple esta pantalla de el pego, estaba por pillarme una china de esas de 4€ hasta que leí todos los comentarios de líos de librerías y montones de fallos. Creo que eso es lo importante de esta comunidad, la experiencia conjunta y el no repetir errores.
Title: Re: Algunos consejos para usar TFT´s
Post by: lightcalamar on Jul 09, 2018, 10:27 am
hasta que leí todos los comentarios de líos de librerías y montones de fallos. Creo que eso es lo importante de esta comunidad, la experiencia conjunta y el no repetir errores.
Por ello hemos escrito, para que no repetir errores.
A estos errores, hemos invertido mucho dinero para daros a conocer otros horizontes.

Por cierto, yo tengo una Nextion de 7 pulgadas, y de momento la tengo en el cajón(no para abandonarla) pero es una HMI sin futuro y ademas mas complicada de programar que una FT81x. te lo escribo, por que tengo de ambos tipos, y donde esten las FTDI, que guarden cola las demas para hacerles sombra

Title: Re: Algunos consejos para usar TFT´s
Post by: arkarash on Jul 27, 2018, 11:21 pm
Ya tengo la Nextion, de momento la experiencia es buena, con el software de Nextion he conseguido fácilmente crear una interfaz para mi botonera a base de imagenes PNG y sustitución de partes de la imagen al pulsar. Gracias a todos por los consejos, me han servido para encontrar una buena opción.

Sobre las pantallas FTDI, se por vuestros comentarios que son mucho mejores que las Nextion pero como ya dije necesitaba una pantalla simple y barata para hacer simplemente un teclado de clave de acceso. Vamos que no lo iba a sacar el jugo con gráfricas ni nada que mereciese la pena el gasto. Sin duda me las miraré para proyectos de más envergadura que tengan más interfaz gráfico.
Title: Re: Algunos consejos para usar TFT´s
Post by: emilts on Aug 20, 2018, 02:33 pm
Hola.

Antes de nada daros las gracias por compartir vuestra gran afición y horas invertidas en aclarar estos temas.

Soy Informático, desde hace muchos años, y al final el tiempo te enseña que lo mejor es utilizar estándares que utilice una mayoría para desarrollar productos y no morir en el intento.

Ahora tengo que hacer un proyecto con arduino, donde soy novato, para controlar emisiones de luz RGB parametrizando valores sencillos desde una pantalla TFT, en principio con controles estándar como botones, "slider-bar", cajas de texto, "scroll-bar", "progress-bar", etc.

La pregunta es, qué TFT táctil me aconsejáis que utilice en torno a 3" o mayor, dado que el tamaño no es problema, pero que me complique lo mínimo, que sea si es posible un shield, de arduino uno en principio, que tenga librerías de programación lo más extendidas y sencillas posible aunque potentes y que no de problemas.

Gracias
Title: Re: Algunos consejos para usar TFT´s
Post by: danielpaz88 on Jan 15, 2019, 10:19 pm
Hola , muy bueno tu aporte. estoy teniendo problemas por que la pantalla está en blanco. EL programa es el siguiente, lo tomé de tu ejemplo TFT_Menu. El driver al parecer es ILI9341. ya no se que hacer he intentado de todo. es una pantalla tft con sd de 2.2" de 240x320.

#include "Adafruit_GFX.h"  
#include "Adafruit_TFTLCD.h"
#include "SD.h"              
#include "SPI.h"            
#include "TouchScreen.h"    

#define YP A1
#define XM A2
#define YM 7
#define XP 6

//Rotacion 3
short TS_MINX = 68; // Controla el final de eje X del lado derecho en rotacion 3
#define TS_MAXX 950  //Controla el inicio de eje X del lado izquierdo en rotacion 3  // no contenpla los botones prediseñados 1-318
short TS_MINY = 170; // inicio Eje  Y
#define TS_MAXY 890  //   fin Eje Y  
//Rotacion 3

#define MINPRESSURE 1
#define MAXPRESSURE 1000
// Instancia del panel tactil (Pin XP, YP, XM, YM, Resistencia del panel)
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 364);

#define LCD_CS A3  
#define LCD_CD A2  
#define LCD_WR A1
#define LCD_RD A0
#define LCD_RESET A4

#if defined __AVR_ATmega2560__
#define SD_SCK 13              
#define SD_MISO 12  
#define SD_MOSI 11
#endif

#define SD_CS 10  
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, A4);

#define BLACK   0x0000  
#define BLUE    0x001F  
#define RED     0xF800  
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF
uint16_t  color;

int X, Y, Z;
int deltaTactil = 10 ; //ajuste tactil-x en botones de diseño, por el uso de iconos prediseñados la tactil es unos 10/12 px mas grande que el TFT

char imagesOnSDCard1[8][30]={"Foff.bmp","Fon.bmp","6oB.bmp","6oH.bmp","6oI.bmp","ico9.bmp","ico7.bmp","La1.bmp"};
unsigned char imagenSD1 = 1;
char TX[50];

//iconos prediseñados
///////acá yo los saque a propósito por que no los uso. aparte me daba error por que me decía que el programa era muy largo y me excedía de la capacidad, estoy usando Android 1.8.7

void setup()
{
 tft.reset();
 tft.begin(0x9325);
 tft.fillScreen(0);
 Serial.begin(9600);

 #if defined __AVR_ATmega2560__              
 if (!SD.begin(SD_CS, SD_MOSI, SD_MISO, SD_SCK ))
 {
   tft.println(F("failed!"));  
   return;
 }
 #else
 if (!SD.begin(SD_CS)) {
   tft.println(F("failed!"));
   return;
 }
 #endif
 tft.setRotation(3);
 //MenuP();
}

void loop(){
 delay(1000);
  bmpDraw("6oB.bmp",140,220);        
   delay(2000);
   bmpDraw("6oH.bmp",170,220);   }
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 16, 2019, 04:27 pm
Hola.

Antes de nada daros las gracias por compartir vuestra gran afición y horas invertidas en aclarar estos temas.

Soy Informático, desde hace muchos años, y al final el tiempo te enseña que lo mejor es utilizar estándares que utilice una mayoría para desarrollar productos y no morir en el intento.

Ahora tengo que hacer un proyecto con arduino, donde soy novato, para controlar emisiones de luz RGB parametrizando valores sencillos desde una pantalla TFT, en principio con controles estándar como botones, "slider-bar", cajas de texto, "scroll-bar", "progress-bar", etc.

La pregunta es, qué TFT táctil me aconsejáis que utilice en torno a 3" o mayor, dado que el tamaño no es problema, pero que me complique lo mínimo, que sea si es posible un shield, de arduino uno en principio, que tenga librerías de programación lo más extendidas y sencillas posible aunque potentes y que no de problemas.

Gracias
Hace un tiempo que no pasaba por el post, espero que mi respuesta no llegue demasiado tarde.

Recientemente he visto una versión de 3.2" de pantallas SPI ILI9341 (320x248 px) (https://es.aliexpress.com/item/240-pulgadas-320-3-2-SPI-serie-TFT-LCD-m-dulo-pantalla-con-controlador-de-Panel/32911859963.html?spm=a2g0s.13010208.99999999.349.7a703c00FDvQFs), es el tope en tamaño para ese controlador. Es de lo mejor en cuanto a si necesitas buena respuesta gráfica al manejar múltiples instrucciones.

Desafortunadamente la parte táctil deja mucho que desear ya que el chip no ha sido actualizado, se sigue empleando el XPT2046 o equivalente. Quizás por mantener el costo final del producto bajo o bien por un elevado stock de ese chip en las empresas que fabrican el TFT.

Existen pantallas un poco más grandes con chips ILI9488 de 3.5" (480x320 px) (https://es.aliexpress.com/item/3-5-pulgadas-480-320-SPI-serie-TFT-LCD-M-dulo-de-pantalla-con-pantalla-t/32908809356.html?spm=a2g0s.13010208.99999999.352.7a703c00FDvQFs), el formato es idéntico al de las ILI9341, usan el chip táctil XPT2046, sin embargo el controlador de pantalla es la actualización directa del chip ILI9341.

Ambas versiones son TFT´s relativamente grandes.

Si tu presupuesto te lo permite te recomendaría pantallas FT813 de 3.5" o de 4.3", NHD tiene pantallas de este tipo con doble conector: un cabezal de 20 pines y un zócalo para cable plano de 20 pines.

(http://www.mediafire.com/convkey/766f/aptamfk269hanmazg.jpg)
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 16, 2019, 04:34 pm
Hola , muy bueno tu aporte. estoy teniendo problemas por que la pantalla está en blanco. EL programa es el siguiente, lo tomé de tu ejemplo TFT_Menu. El driver al parecer es ILI9341. ya no se que hacer he intentado de todo. es una pantalla tft con sd de 2.2" de 240x320...
Bueno primero que nada felicidades por intentar un proyecto diferente. Te prevengo: habrá varias conexiones fallidas, pero ya diste el primer paso.

Veo en la foto que has compartido, que usas un cableado bastante largo, procura que el tamaño total de cada hilo no supere los 15 cm.

Las resistencias deben estar conectadas en forma de divisor de voltaje 5V/3.3V para cada línea de control de la pantalla, excepto para VCC y GND. Si te es posible consigue un chip CD4050BE, te ahorrará dolores de cabeza.

La mejor librería que puedes usar es esta (https://forum.arduino.cc/index.php?topic=265806.0)
Title: Re: Algunos consejos para usar TFT´s
Post by: JOSEBERMUDEZ on Jan 21, 2019, 10:55 pm
Hola, soy jose y soy nievo en esto de las pantallas tft, a ver si podeis ayudarme porque ando muy perdido y nadie me hecha un cable, queria empezar por algo sencillo, encender y apagar un rele desde un icono el la pantalla tft. No se por donde empezar, os agradezco de antemano vuestra ayuda.
Title: Re: Algunos consejos para usar TFT´s
Post by: TFTLCDCyg on Jan 22, 2019, 07:08 pm
Hola, soy jose y soy nievo en esto de las pantallas tft, a ver si podeis ayudarme porque ando muy perdido y nadie me hecha un cable, queria empezar por algo sencillo, encender y apagar un rele desde un icono el la pantalla tft. No se por donde empezar, os agradezco de antemano vuestra ayuda.
Esto del hobby con arduino implica que inviertas parte de tus ahorros en las piezas que quieres usar y antes que nada soy muy respetuoso con ese tema. Para empezar, te podría recomendar 6 o 7 opciones de TFT, pero quizás terminarás por sustituir por algo mucho mejor, por eso antes de opinar al respecto, me gustaría precisar algunas ideas.

Como siempre he dicho, mis opiniones son imparciales respecto a los fabricantes: si me sirve un TFT lo usaré en el proyecto, sino, irá directo al cajón de cosas sin usar y no lo recomendaré más, simplemente para evitar dolores de cabeza.

Bajo esta premisa, me he topado con piezas que han resultado algo costosas, pero que no he vuelto a usar, porque el TFT luego de un tiempo de uso muestra alguno que otro defecto. Sin olvidar el tiempo invertido en la curva de aprendizaje de la librería de control; que en varias ocasiones me ha retrasado el proyecto principal.

Ahora bien, en tu comentario veo que quieres un TFT con panel táctil con capacidad para gestionar imágenes. En ese sentido es mejor que te alejes de los TFT con táctil resistivo, el tema de cableado, calibración y sensibilidad dan paso a muchos problemas.

Los TFT con táctil capacitivo son de lejos la mejor opción.

Desafortunadamente la tecnología capacitiva está poco documentada en arduino y el universo de pantallas está muy reducido. Además el costo de este tipo de pantallas supera com mucho los 3 o 4 USD de las pantallas resistivas.

El complemento al TFT que quieres es el manejo de imágenes. Aquí necesitarás un lector micro SD para el manejo de archivos; esto ayudará que tu código consuma poca memoria en la placa de control o MCU

Otro aspecto a considerar es un buen MCU: muchos pines y capacidad para gestionar con librerías todo el hardware que quieres en tu proyecto.

Verás en internet demasiados proyectos muy bien logrados, pero no todo lo que dicen está documentado, el trasfondo implica que el dueño del proyecto pasó infinidad de horas creando sus propias librerías y que no siempre están dispuestos a compartir, quizás porque tienen un negocio detrás que deben cuidar...

El formato de la pantalla es importante: es mejor usar pantallas con pocos hilos de control y con cableado corto hacia el MCU.