Algunos consejos para usar TFT´s

Que ya veas que sirva con la librería para gameduino 2, es un enorme avance. :art:

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

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.

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;

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

Resultado;

Montar la red R+C exterior;

Como quedo compilado con IDE de Arduino 1.6.5;

y otra mas;

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

Saludos! :slight_smile:

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.

Buenas.
Doy hoy por decir esto;

La pantalla FT800 de este modelo;

comprada en esta tienda de Hong-Kong 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);

#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;

#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;

GD.begin(0);

y en el segundo pone;

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:

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:

#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);

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;

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

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.

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;

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;

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.

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!!! :slight_smile:

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.

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

lightcalamar:
...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.

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

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

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.

Skecth e imágenes usadas en la prueba

Me aplico en el trabajo y dejaré la prueba en proceso, ya veremos mas tarde como se comporta el experimento.

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!

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

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

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

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.

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.

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;

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?

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.

Es algo curioso, la librería FTDI tolera mayor longitud

De acuerdo con tu idea. Hay otro:

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.

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:

GD.Tag(255);

Al final de cada linea que asigna un número de tag

El tag "0"

GD.Tag(0);

Causa errores en los tags definidos en la misma pantalla, recomiendo no usarlo.

Muchas gracias por los consejos :slight_smile:

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:

#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);    
}


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:

#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();
}


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.

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

#define Personal tft.color565(60, 60, 60)

Librería y hardware

Las librerias base son

#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"

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

//(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

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

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

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
}

Ejemplo de uso

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

Buenas noches @TFTLCDCyg

Ayer recibí mis dos pantallas FT811CB y otra FT800CB desde Singapore de la Tienda THAOYU Electronicsy 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!!! :slight_smile: 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.