Como quitarle el parpadeo del delay y No me deja utilizar esta funte en LCD

Hola chicos primero quiero solucionar el tema de la fuente. Me pasa que me descargado otra fuente para mi lcd de la pagina de la libreria UTFT que es mas grande que los que trae de defecto.

Primero he puesto el: #include "fonts/font_SevenSeg_XXXL_Num.c"

Luego el: extern uint8_t SevenSeg_XXXL_Num;

Y ahora esta donde quiero que aparezca: myGLCD.setFont(SevenSeg_XXXL_Num);

myGLCD.printNumI("0",CENTER,CENTER);

El error es este:

LCD_display_2015.ino:13:42: fatal error: fonts/font_SevenSeg_XXXL_Num.c: No such file or directory
compilation terminated.
Error de compilación

Viendo esto he imaginado que el archivo SevenSeg_XXXL_Num.c esta mal colocado. Esta en la carpeta librerias. He intentado meterlo en la carpeta utft y tampoco hace.

La segunda question es que los datos que me muestra el display hacen como un refresco.Esta parpadeando constantemente. Hay alguna manera de poder quitarle el parpadeo?

Gracias.

1: El archivo de la fuente debe ir en la carpeta del sketch en el que la quieres usar. Para poder emplearla en el sketch, sigues el procedimiento que has descrito

2: Los efectos indeseables como "números sobrantes" o "fragmentos de texto" que no se pueden evitar usando directamente la impresión printNumI o printNumF; se pueden evitar usando una "máscara", es decir se dibuja un rectángulo del color del fondo del texto y encima se imprime el valor actual, el número se presenta completo pero, se tiene el problema que mencionas como "parpadeo".

Para evitar esos efectos, puedes hacer lo siguiente:

a) Crea una variable tipo char en la que mandarás todos los valores numéricos para sean impresos en pantalla, por ejemplo

char textBuff[20];

No es necesario que crees una variable de este tipo para cada valor numérico; es una variable que solo sirve para imprimir números.

b) Todos los valores numéricos que quieras presentar en pantalla los conviertes en texto de esta forma:

 sprintf(textBuff, "%03d", LectT);      
 myGLCD.setFont(SevenSeg_XXXL_Num); myGLCD.setColor(WHITE);  myGLCD.print(textBuff, 120, 35);

Hola y primero gracias por responder. He metido el archivo. C en la carpeta donde tengo el programa de arduino y no hace. Alguna sugerencia?

txinas:
Hola y primero gracias por responder. He metido el archivo. C en la carpeta donde tengo el programa de arduino y no hace. Alguna sugerencia?

Hola.
Según tu include, creo que tienes que crear dentro de la carpeta de tu sketch una carpeta que se llame fonts, y dentro de ésta el archivo.c de la fuente correspondiente.
Saludos.

txinas:
Hola y primero gracias por responder. He metido el archivo. C en la carpeta donde tengo el programa de arduino y no hace. Alguna sugerencia?

Aquí persiste el problema en torno a como funcionan los sketchs, vayamos por partes.

Cada vez que guardas un sketch, dentro de la carpeta

C:\Users\XX\Documents\Arduino

Se crea otra carpeta que se llama como el sketch que has guardado, por ejemplo, estoy revisando tu problema y cree este sketch: Prueba Font.ino. Entonces se crea esta carpeta de forma automática:

C:\Users\XX\Documents\Arduino\Prueba_Font

En esa carpeta (o como sea que le hayas llamado a tu proyecto) es en la que debes guardar el archivo SevenSeg_XXXL_Num.C. Entonces tendrás tu sketch y el archivo de fuente extra juntos en una misma carpeta.

Defines tu fuente en el sketch

extern uint8_t SevenSeg_XXXL_Num[];

Y la usas en la presentación de resultados en pantalla, por ejemplo:

 int LectT = lectura[j];      
  sprintf(textBuff, "%03d", LectT);
  myGLCD.setFont(SevenSeg_XXXL_Num); myGLCD.setColor(WHITE);  myGLCD.print(textBuff, 120, 35);

Solo así podrás usar la fuente.

Hola pues ya lo he consegido pero una cosilla queria preguntarte, he probado con diferentes tipos de letras pero querria hacer una letra yo mismo. Quiero hacer unos numeros grandes en ariel. Puedo yo mismo modificar en el archivo ArialNumFontPlus.c el tamaño? En caso de si que cambios tendria que efectuar?

Gracias.

No he hecho pruebas con esa parte de la librería UTFT, sin embargo hay una utilidad para construir fuentes:

http://www.rinkydinkelectronics.com/t_make_font_file.php

Podrías intentar por allí.

PD: que bien que has conseguido hacer funcionar la fuente en tu proyecto.

TFTLCDCyg estoy toda la mañana intentando solucionar lo del parpadeo. Te voy a escribir mi parte de programa y si tienes un momento me ayudas. Perdona por la molestia.

myGLCD.setColor(VGA_RED);    // Color de las revoluciones, en este caso rojo. Segimos el mismo patron con los de mas datos
myGLCD.setFont(BigFont);
myGLCD.print("RPM", 550, 130);
myGLCD.setFont(SevenSegNumFont);
myGLCD.printNumI(Rpm, 550, 75);

Abajo tengo la función que saca el calculo del RPM. Para que no me haga el parpadeo como lo tengo que cambiar?

Gracias.

Con el fragmento que has colocado no podría decirte como proceder. Te dejo el ejemplo en el que que usado la fuente que quieres implementar, junto con otras más que bajé de la página de UTFT y “sin parpadeos”. Incluso la fuente se sobreescribe sobre una gráfica de puntos, igual y te sirve en tu proyecto.

Está diseñada para un TFT de 320x240, es parte de un proyecto más grande, pero el módulo funciona, ya que sustituí el lector NTC por un generador aleatorio de temperaturas, a ver si así puedes resolver tus dudas.

Recuerda cambiar el encabezado para que coincida con tu TFT. Funciona en arduino MEGA y Due. Dejo el link de descarga con el ejemplo completo y las fuentes extra

Debes ver algo como esto en tu TFT, en este caso se trata de un TFT ILI9341 de 2.8" sobre un arduino Due. Considera que el MEGA tiene 16Hz y el Due corre a 84 Hz, por allí el refresco de la pantalla también debe jugarte en contra.

// Rolling_Graph_TFT_320x240 by Cyg
// UTFT library by (C)2014 Henning Karlsen
// web: http://www.henningkarlsen.com/electronics

#include <UTFT.h>
#include <UTouch.h>
UTFT myGLCD(ILI9341_S5P,MOSI,SCK,10,NOTINUSE,9); //ILI9341 2.8"

// Tabla de colores
#define BLACK           0x0000
#define RED             0xF800
#define GREEN           0x07E0
//#define BLUE            0x001F
#define BLUE            0x102E
#define CYAN            0x07FF
#define MAGENTA         0xF81F
#define YELLOW          0xFFE0 
#define ORANGE          0xFD20
#define GREENYELLOW     0xAFE5 
#define DARKGREEN       0x03E0
#define WHITE           0xFFFF

char textBuff[20];

// tipo de fuente para UTFT
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
extern uint8_t SmallFont[];
extern uint8_t arial_normal[];
extern uint8_t arial_italic[];
extern uint8_t arial_bold[];
extern uint8_t nadianne[];
extern uint8_t swiss721_outline[];
extern uint8_t Sinclair_S[];
extern uint8_t TinyFont[];
extern uint8_t ArialNumFontPlus[];
extern uint8_t SevenSeg_XXXL_Num[];   //http://www.rinkydinkelectronics.com/r_fonts.php


 //***********************Sensor NTC en A7

//   Conexion del NTC-A7 al arduino
//   El pin libre del  NTC-A7  va a GND
//   El pin de la resistencia va a 3.3 
//   El pin unido entre resistencia y NTC va a al pin de adquisición de datos, en este caso al pin A7  del Arduino

 //Pin de datos del divisor de voltaje para el NTC-A7
    float analogPin=A7;   // Entrada del divisor del voltaje
    float Lectura;        // activar variable para las lecturas
    float TempC;          // variable de temperatura calculada
    int TA7;               // para manejar los decimales
    
//    Calibración del NTC-A7 hecha con 3.3 V
    
    // Ambiente  
    float TempX1=21.6;          // temperatura ambiente
    float LectY1=569;          // lectura ambiente
   
   // Dedos 
    float TempX2=36.6;          // temperatura dedos
    float LectY2=440;          // lectura dedos
    
// Calculos intermedios
    float p= -1 * ((LectY2 - LectY1)/(TempX2 - TempX1));                  // pendiente de la recta

//Lista de capturas de datos de temperatura del NTC-7
  const int maxlecturas = 299;   // Variable clave que permite manipular el tamaños de todos los arrays de datos
//  const int maxlecturas = 50;   // Variable clave que permite manipular el tamaños de todos los arrays de datos
  float lectura[maxlecturas];  // base de datos actual
  float lecturaprevia[maxlecturas]; // base de datos previa
  int j;  // contador para recorrer los datos de la lista actual
  int xinicial=16;  // posición en X a partir de la que se graficarán los datos
  int Tbaseparay=0;  // temperatura arbitarria base que deseamos ver en pantalla
  int ydeseada = 210;   // punto en y donde queremos que se coloque la temperatura de referencia Tbaseparay
  int escala=1;  // número de pixeles entre cada grado centígrado
  int ybase=ydeseada + escala*Tbaseparay;  //   valor al que debemos restar escala*TempC. Ajusta la base de la gráfica


//Lectura del sensor NTC
void LecturaNTC()
{
  //Dato del NTC-A7
    Lectura=analogRead(analogPin);
// Conversión de lectura en temperatura
//   TempC= TempX1 + ((LectY1 - Lectura)/p);  
   TempC = random(20,123);

}

void setup() {

  myGLCD.InitLCD();
  myGLCD.clrScr();  
  myGLCD.setFont(SmallFont);
  myGLCD.setColor(WHITE);
  myGLCD.print("Iniciando TFT ILI9341 2.8...", 45, 120);     
  delay(2000);


//Limpia pantalla
  myGLCD.clrScr();  
  myGLCD.fillScr(BLUE);

// Genera base de datos inicial
  lineabaseNTC1();

// Texto fijo 
  myGLCD.setBackColor(BLUE);  
  myGLCD.setFont(swiss721_outline);   
  myGLCD.setColor(WHITE);  myGLCD.print("Temperatura", 17, 7);  
  myGLCD.setFont(TinyFont); 
  myGLCD.setColor(WHITE);  myGLCD.print("ambiente",127,24);  
  
// Marco y marcadores para graficar temperaturas
  myGLCD.setColor(RED);
  myGLCD.setBackColor(BLUE);
  //Divisores eje X
  for (int i=15; i<316; i+=10)
    myGLCD.drawLine(i, 226, i, 231);
  // Divisores eje Y
  for (int i=75; i<226; i+=10)
    myGLCD.drawLine(9, i, 14, i);
  myGLCD.setColor(RED);   myGLCD.drawRect(15, 75, 315, 225);   // marco para gráfica
}


//función para generar la base de datos inicial
void lineabaseNTC1()
{
  for (int i=0; i<maxlecturas; i++)
      {
        //myGLCD.setColor(255,255,255); 
        LecturaNTC();
        lectura[i] = TempC;   
      }        
}  

void grafica()
{

     lecturaprevia[j]=lectura[j];  // almacena el dato actual
     
// Recorre una sola posición. Los datos de la lista se recorren de adelante hacia atrás, para dejar libre el último espacio
// de la lista
     lectura[j] = lectura[j+1];  

     myGLCD.setColor(BLUE);  myGLCD.drawPixel(j+xinicial, ybase-escala*lecturaprevia[j]); //borra el pixel previo
     myGLCD.setColor(GREEN);  myGLCD.drawPixel(j+xinicial, ybase-escala*lectura[j]); //grafica el pixel nuevo
     j++;

// Continua recorriendo los datos hasta llegar al último de la lista, en el que se colocará la nueva lectura de
// temperatura del sensor
      if (j==maxlecturas-1)
       {
         LecturaNTC();
         myGLCD.setColor(255,255,255);  
         lecturaprevia[j]=lectura[j];         
         lectura[j] = TempC;  // lectura del sensor NTC en el pin A7

    int LectT = lectura[j];      
    sprintf(textBuff, "%03d", LectT);
    myGLCD.setFont(SevenSeg_XXXL_Num); myGLCD.setColor(WHITE);  myGLCD.print(textBuff, 120, 35);  
         
         myGLCD.setColor(BLUE);  myGLCD.drawPixel(j+xinicial, ybase-escala*lecturaprevia[j]); //borra el pixel previo
         myGLCD.setColor(GREEN);  myGLCD.drawPixel(j+xinicial, ybase-escala*lectura[j]); //grafica el pixel nuevo
         j=0;
       }
  
}  


void loop()
{
  grafica();
}

PD: el código no está pulido por la razón de que esa librería me resulta muy lenta y actualmente estoy trabajando con un TFT que tiene su propio procesador gráfico basado en un FT800.

TFTLCDCyg gracias por responder pero sinceramente no me entero de nada. Aquíi te dejo mi programa

#include <UTFT.h>
char textBuff[20];


// QUE CLASE DE FUENTE UTILIZAR
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
extern uint8_t ArialNumFontPlus[];  
extern uint8_t SevenSeg_XXXL_Num[];
extern uint8_t SixteenSegment96x144Num[];
// Set the pins to the correct ones for your development shield
// ------------------------------------------------------------
// Standard Arduino Mega/Due shield            : <display model>,38,39,40,41
// CTE TFT LCD/SD Shield for Arduino Due       : <display model>,25,26,27,28
// Teensy 3.x TFT Test Board                   : <display model>,23,22, 3, 4
// ElecHouse TFT LCD/SD Shield for Arduino Due : <display model>,22,23,31,33
//
// Remember to change the model parameter to suit your display module!
UTFT myGLCD(CPLD,25,26,27,28);
char comandos;
int Rpm=0, Speed=0, Fuel=0, Gear, Oil=0, Agua=0, module;

void setup()
{
  randomSeed(analogRead(0));
  Serial.begin(38400);

// INICIALIZAR LCD
  myGLCD.InitLCD();
  myGLCD.clrScr();
}

void loop()
{

   while(Serial.available() > 0) 
   {
     while(Serial.available() > 0) 
     {
     char comandos = Serial.read();
     if (comandos == 'S') Read_Speed();
     if (comandos == 'R') Read_Rpm();
     if (comandos == 'F') Read_Fuel();
     if (comandos == 'O') Read_Oil();
     if (comandos == 'A') Read_Agua();
     if (comandos == 'G') Read_Gear();
     }

    
   }

  
 

 
//COLOR DE LA PANTALLA 
  
  myGLCD.fillScr(VGA_BLACK);
  myGLCD.setBackColor(VGA_BLACK);
  
//ESCRIBIR RPM
  
   
  myGLCD.setColor(VGA_RED);    // Color de las revoluciones, en este caso rojo. Segimos el mismo patron con los de mas datos
  myGLCD.setFont(BigFont);
  myGLCD.print("RPM", 550, 130);
  myGLCD.setFont(ArialNumFontPlus);
  myGLCD.printNumI(Rpm, 550, 75);
  
//ESCRIBIR TEMPERATURA DE ACEITE
  
  myGLCD.setColor(VGA_YELLOW);
  myGLCD.setFont(BigFont);
  myGLCD.print("OIL", 550, 215);
  myGLCD.setFont(ArialNumFontPlus);
  myGLCD.printNumI(Oil, 550, 160);

//ESCRIBIR GASOLINA
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(BigFont);
  myGLCD.print("FUEL", 550, 300);
  myGLCD.setFont(ArialNumFontPlus);
  myGLCD.printNumI(Fuel, 550,245);
  
//ESCRIBIR TEMPERATURA DE AGUA
  myGLCD.setColor(VGA_BLUE);
  myGLCD.setFont(BigFont);
  myGLCD.print("AGUA", 550,385);
  myGLCD.setFont(ArialNumFontPlus);
  myGLCD.printNumI(Agua,550,330);
  
//ESCRIBIR VELOCIDAD
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(BigFont);
  myGLCD.print("KPH", 50,150);
  myGLCD.setFont(SevenSeg_XXXL_Num);
  myGLCD.printNumI(Speed,50,75);
 









//ESCRIBIR CAMBIO
  myGLCD.setFont(ArialNumFontPlus);
  myGLCD.printNumI(Gear,CENTER,CENTER);

 // delay(1);

}
void Read_Rpm()
{
  {
  delay(1);
  int Rpm1000 = Serial.read() - 48;
  int Rpm100 = Serial.read() - 48;
  int Rpm10 = Serial.read() - 48;
  int Rpm1 = Serial.read() - 48;
  Rpm = 1000*Rpm1000 + 100*Rpm100 + 10*Rpm10 + Rpm1;
  } 
} 
void Read_Speed()
{
  {
  delay(1);
  int Speed100 = Serial.read() - 48;
  int Speed10 = Serial.read() - 48;
  int Speed1 = Serial.read() - 48;
  Speed = 100*Speed100 + 10*Speed10 + Speed1;
  }
}  
void Read_Fuel()
{
  {
  //delay(1);
  int Fuel100 = Serial.read() - 48;
  int Fuel10 = Serial.read() - 48;
  int Fuel1 = Serial.read() - 48;
  Fuel = 100*Fuel100 + 10*Fuel10 + Fuel1;
  }
}

void Read_Oil()
{
  {
  delay(1);
  int Oil100 = Serial.read() - 48;
  int Oil10 = Serial.read() - 48;
  int Oil1 = Serial.read() - 48;
  Oil= 100*Oil100 + 10*Oil10 + Oil1;
  }

}

void Read_Agua()
{
  {
  delay(1);
  int Agua100 = Serial.read() - 48;
  int Agua10 = Serial.read() - 48;
  int Agua1 = Serial.read() - 48;
  Agua= 100*Agua100 + 10*Agua10 + Agua1;
  
  }
}




void Read_Gear()

{
  Gear=Serial.parseInt();
}

Aqui te dejo un enlace donde puedes ver el parpadeo.

Gracias y perdon por la molestia

No hay molestia. Por el video se ve que ocurre limpieza de pantalla a cada instante, por eso es el parpadeo, nada que ver con el formato de las fuentes como supuse.

Quita esto del loop

//COLOR DE LA PANTALLA 
  
  myGLCD.fillScr(VGA_BLACK);
  myGLCD.setBackColor(VGA_BLACK);

Ubícalas como instrucciones finales en el setup

PD: como recomendación, en lo futuro sube tu código completo desde el planteamiento del problema, así nos evitamos “el viaje de las cabras al monte”.

Gracias ha funcionado a la primera.Otra cosa mas aprendida. Si alguien quiere saber como va el display podeis ver como va el display aqui:

http://www.xtremeracers.info/forums/viewtopic.php?f=45&t=11707

Gracias de todo corazon por ayudarme.