efecto espejo en pantalla tactil

Gabriela Chamorro

Lanero Regular
5 Feb 2015
11
Estoy empezando a trabajar con las pantallas táctiles y tengo un problema que no se como resolverlo ya que soy nueva en esto quisiera que por favor me ayuden... Mi problema es que todo me sale con un efecto espejo (al revés letras y gráficos), trabajo con una pantalla UTFT de arduino y con el arduino MEGA esto es lo que obtengo
10928644_913099282044339_1549712920_n.jpg
 
¿Qué modelo de TFT estás usando?, ¿que chipdriver usa?

¿Tienes un link hacia una página en la que se puedan ver las especificaciones y modelo exácto de tu TFT?
 
Cómo me lo esperaba, el proveedor no da detalles respecto a las librerías que se deben usar.

En primer instancia te recomiendo usar uno por uno, los modelos que refieren al controlador SSD1963 y sus variantes.

Revisa estos temas:
link 1
link 2
 
¿Lograste eliminar el "efecto espejo"?.

- ¿Qué sensores vas a monitorear?
- ¿Tienes un sketch de partida?, si es así súbelo para ver que avance llevas y saber de dónde vamos a partir.
 
Código:
#include <UTFT.h>
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];

volatile int NbTopsFan;
int Calc;
int hallsensor = 8;
int sensorPin = A0;    // select the input pin for the potentiometer
int ledPin = 13;      // select the pin for the LED
int sensorValue = 0;  // variable to store the value coming from the sensor
void rpm ()
{
NbTopsFan++;
}
UTFT myGLCD(ITDB43,38,39,40,41);

void setup()
{
  myGLCD.InitLCD();
  myGLCD.clrScr();
pinMode(hallsensor, INPUT);
Serial.begin(9600);
attachInterrupt(8, rpm, RISING);
}
void loop ()
{
  myGLCD.setFont(BigFont);
  myGLCD.print("ESPOCH", CENTER, 2);
NbTopsFan = 0;

delay (1000);

Calc = (NbTopsFan / 5.5);
Serial.print (Calc, DEC);
Serial.print (" Litros/min\r\n");

//sensorValue = analogRead(sensorPin);   
  myGLCD.printNumI(Calc ,60,40);
  // turn the ledPin on
  //Serial.println(sensorValue); 
  myGLCD.setFont(SmallFont);
  myGLCD.print("LT/MIN",5,20);
  //for (int i=1; i<478; i++)
  //{
  //  myGLCD.drawPixel(i,sensorValue);
  //}
//myGLCD.setColor(255,255,0);
myGLCD.drawLine(1, 30, 1, 200);
  myGLCD.drawLine(1, 135, 478, 135);
  myGLCD.print("SENSOR DE FLUJO", 5, 255);
  for (int i=100; i<300; i++)
  {
    myGLCD.drawPixel(i,Cal);
 
  }
}
voy a monitorear un sensor de flujo y quisiera obtener una gráfica en función del tiempo, y tengo mi sketch de la siguiente manera
 
Modifiqué el sketch, solo debes corregir los cálculos mediante los cuales obtienes el valor de la variable Calc, que según veo en tu skecth es la que usas para convertir los datos del sensor de flujo.

La sustituí por un generador de números aleatorios entre 0 l/min a 130 l/min, que es el rango de escala del marco de la gráfica

Código:
  Calc = random(0,130);   //  Borra esta linea, para que coloques los cálculos del sensor de flujo

Como te señalo, debes eliminar ese generador y colocar la ecuación correcta que permite obtener los litros/minuto de tu sensor de flujo.


Código:
#include <UTFT.h>
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];

UTFT myGLCD(ITDB43,38,39,40,41);

volatile int NbTopsFan = 0;
int Calc;
int hallsensor = 22;
int sensorPin = A5;    // select the input pin for the potentiometer
int ledPin = 13;      // select the pin for the LED
int sensorValue = 0;  // variable to store the value coming from the sensor

// Parámetros de la gráfica
int xinicial = 16; int ybase = 215;   //   corresponde a la base de la gráfica de 0 l/min
int escala = 1; // número de pixeles entre cada grado centígrado
const int maxlecturas = 298; // Número máximo de datos en las bases de datos
  float lectura[maxlecturas];  // lista o base de datos de las lecturas actuales
  float lecturaprevia[maxlecturas]; // lista o base de datos de las lecturas previas
  int j;  // contador para recorrer los datos de la lista actual

char textBuff[20];  //  Convierte valores numéricos a caracteres de texto


void setup()
{
  myGLCD.InitLCD();
  myGLCD.clrScr();
pinMode(hallsensor, INPUT);
Serial.begin(9600);
attachInterrupt(22, rpm, RISING);
// Marco y marcadores para graficar temperaturas
  myGLCD.setColor(255,0,0);
  //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);
  // Marco para gráfica  
  myGLCD.setColor(255,0,0);   myGLCD.drawRect(15, 75, 315, 225);
  myGLCD.setColor(255,255,255);
  myGLCD.setFont(BigFont);
  myGLCD.print("ESPOCH", CENTER, 2);
  myGLCD.setFont(SmallFont);
  myGLCD.print("SENSOR DE FLUJO", 105, 22);
  myGLCD.setFont(BigFont);
  myGLCD.print("l/min",105,40);

  // Genera base de datos inicial
  lineabase();

}



void rpm ()
{
  NbTopsFan++;
}


void leersensor()
{
  rpm();
  Calc = (NbTopsFan / 5.5);

  Calc = random(0,130);   //  Borra esta linea, para que coloques los cálculos del sensor de flujo
}


//función para generar la base de datos inicial
void lineabase()
{
  for (int i=0; i<maxlecturas; i++)
      {
        leersensor();
        lectura[i] = Calc;
      }      
}



void grafica1()
{
   for (int i=xinicial; i<maxlecturas; i++)
  {
    myGLCD.drawPixel(i+xinicial,ybase - Calc);
  }
}


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(0,0,0);  myGLCD.drawPixel(j+xinicial, ybase-escala*lecturaprevia[j]); //borra el pixel previo
     myGLCD.setColor(0,255,0);  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
// del sensor
      if (j==maxlecturas-1)
       {
         leersensor();
         lecturaprevia[j]=lectura[j];       
         lectura[j] = Calc;
     
         myGLCD.setColor(255,255,255);  sprintf(textBuff, "%03d", Calc);   myGLCD.print(textBuff,52,40);
       
         myGLCD.setColor(0,0,0);  myGLCD.drawPixel(j+xinicial, ybase-escala*lecturaprevia[j]); //borra el pixel previo
         myGLCD.setColor(0,255,0);  myGLCD.drawPixel(j+xinicial, ybase-escala*lectura[j]); //grafica el pixel nuevo
         j=0;
       }
}


void loop ()
{
  grafica();
}

Tengo un arduino Due en lugar del arduino MEGA que tienes, por lo que creo que los 16 MHz van a sufrir bastante.

Considera que los arduinos AVR son algo limitados con el tema de la velocidad y aspectos gráficos.
 
Muchas gracias por su ayuda he trabajado con el sensor de flujo y he obtenido muy buenas gráficas...!!!
Ahora bien tengo un pequeño problema ya que para mi trabajo estoy utilizando también un sensor de presión nunca había trabajado con uno, mi sensor es el mpx5010gp. No se si usted ha trabajado con este sensor y me pueda ayudar con algunas recomendaciones para poder obtener una gráfica
 
Última edición:
No he trabajado con ese sensor, pero no creo que tengas problemas para hacerlo funcionar. Es un sensor simple: GND, 5V, data. Es semejante a la forma en la que se conectan los sensores de temperatura NTC. Mira el link que te adjunto para que te des una idea de como usarlo.

http://learn.parallax.com/pressure-sensor-arduino-demo

El pin Data, basta con que lo conectes a un pin analógico de tu arduino. Te dejo otro link para que veas como se manejan los sensores que se conectan a un pin analógico.

http://www.tr3sdland.com/2011/12/tutorial-arduino-0005-sensor-de-temperatura-ntc/

Como obtienes un dato de voltaje desde el sensor, debes realizar una calibración simple, mediante dos puntos en los que la variable que vas a medir (presión para el sensor que tienes), adquiere valores fijos.

Se me ocurre un ejemplo con un sensor de temperatura, por ejemplo mides cuanto voltaje lees con el pin analógico, cuando metes el sensor en agua a 20 C. Haces lo mismo calentando el agua a una temperatura como 40 C, tomas ese segundo valor de voltaje del arduino.

Si recuerdas tus clases de estadística, puedes obtener la calibración, obteniendo la ecuación de la recta que pasa por los dos puntos que mediste.

Luego la lectura del sensor la metes en la ecuación de la recta y calculas el dato de la temperatura. Debes hacer lo mismo con el sensor de presión que tienes.

Si quieres obtener la curva del sensor real, puedes medir el voltaje a otros valores de temperatura y aplicas una regresión lineal cuadrática, logarítimca, exponencial, etc, de acuerdo con la gráfica de calibración que obtengas. No sé como se comporte la presión, pero en rangos cortos la calibración lineal debe funcionar bien.

PD: en el proyecto actual tengo un sensor NTC, me falta calibrarlo, pero ya puedo mandar los datos a la pantalla. La gráfica funciona de forma diferente al sketch que te compartí antes, ya que esta pantalla funciona con un procesador gráfico FT800 y puede manejar frecuencias de refresco de hasta 60Hz, lo que da muchos mas FPS que la pantalla que tienes.


Sigo experimentado con los comandos de la pantalla por lo que la muestra del video tiene varios componentes corriendo al mismo tiempo, no es un proyecto terminado aún.
 
Gracias Cygnus he logrado obtener las dos gráficas de mis sensores y quiero seguir avanzando en mi proyecto muy pronto subiré un video o fotos de como esta pero quisiera saber ahora como hacer para con botones aumentar o disminuir el flujo del aire y la presión de salida claro esta desde mi pantalla me podría ayudar..??
 
El paso que tienes en mente implica que aprendas a usar la pantalla táctil para la creación primero de menús y luego de botones que te permitan aumentar o disminuir la salida de voltaje. No sé que pretendas controlar, un servomotor o una electroválvula, pero en general el principio es simple.

Requieres de un menu principal desde el puedas acceder a un menu de control, en el que estarán los botones de aumento y de reducción y un par de indicadores numéricos que te muestren los cambios en la variable de control: voltaje o velocidad de flujo. Un tercer boton te permitirá regresar al menu principal. También en el menu principal puedes contar con otro botón que te mande a la gráfica. También en la gráfica podrías tener los dos botones aumento/reducción, indicadores numéricos y abajo; la gráfica del sensor que estas monitoreando, de esta forma podrás ver en tiempo real los ajustes que estas realizando.

Si cuentas con dos o mas sensores por graficar, en cada uno de ellos deberías disponer de la configuración para que tengas control en tiempo real.

Los botones de aumento/reducción, deben tener asociado un contador común para el control de los dispositivos, así podrás hacer los ajustes con la misma variable que pretendes controlar. Para evitar fallos en tu equipo debes establecer limites de control, por ejemplo que tu botón de reducción tenga un limite inferior: 10 l/min y el de incremento a un limite superior como 130 l/min por ejemplo.

La librería de control de la pantalla táctil es esta: utouch. A partir de aquí debes primero calibrar tu pantalla y obtener los parámetros de ajuste que debes usar en el archivo UtouchCD.h.

Te dejo un ejemplo de manejo de menus y botones con la libreria UTFT y Utouch. Para usarlo, debes ajustar los parámetros de tu pantalla como calibración, pines de la pantalla táctil y modelo de chip de tu pantalla
 
Última edición:
Muchas gracias tenia un poco adelantado el trabajo y he solucionado todo respecto al tema de calibración revisaré el programa para poder utilizar de ahí la base para desarrollar un programa que se ajuste a mis necesidades espero poder responder muy pronto con noticias positivas y con un sketch de lo realizado.
Saludos
 
Va a sonar muy extraño pero he cambiado mi pantalla de 7 por una de 4.3 pulgadas debido a que el proyecto que realizo necesita una pantalla mas pequeña por lo referente a espacio pero tengo un problema es que he calibrado mi pantalla pequeña tal y como la anterior hago una prueba con el demo de los botones y todo en cuanto al touch me sale cambiado entonces hago una calibracion y cambio mis valores en el UtouchCD y despues de esto deja de funcionar totalmente el touch.
 
Cygnus Buenos días le cuento que he solucionado el problema de mi pantalla pequeña solo he modificado en el demo de calibración esta linea de código #define TOUCH_ORIENTATION LANDSCAPE que le pongo aquí.

Por otro lado el programa que me ha enviado me ayudo mucho y estoy realizando ya mi programa para mi proyecto muchas gracias por toda su ayuda espero seguir avanzando bien.
 
Hola me podría ayudar yo quiero medir el flujo de aire con un sensor mpx 5050dp conectado a un tubo venturi el cual va en serie con un flujometro para poder establecer los rangos de litros por minuto, pero cuando tengo una oposición de aire el sensor no me mide nada, y cuando esta libre el tubo venturi si tengo mediciones..
 
Muchachos tengo problema similar con mi tft 9327 los textos se muestran al revez, las imagenes las corregi en problema RGB y rotacion, pero el texto aun no lo resuelvo, ocupo la libreria.
Adafruit_GFX.h
Adafruit_TFTLCD.h
SPI.h>
SD.h

Favor alguien me ayude!!!
Gracias!!
 

Los últimos temas