Pages: 1 2 [3]   Go Down
Author Topic: ITDB02 5.0 Y UTouch  (Read 2822 times)
0 Members and 1 Guest are viewing this topic.
Vilalba, Lugo, Spain
Offline Offline
Sr. Member
****
Karma: 23
Posts: 336
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Un paciente llega al laboratorio donde debe entregar una muestra de semen para analizar, y le dice a la enfermera:

Lo intente con una mano, luego con la otra ...
Lo intento mi esposa a dos manos...
Lo intento mi suegra, hasta con la boca ...

.. y le aseguro enfermera que no hay manera, el condenado frasco ne se abre...

Noter, a mi tampoco se me abre el frasco,   smiley-cry

Me pierdo con tanto nombre y parámetro. Me da errores por docenas...

Si no te molesta, podríamos dar dos pasos a tras?

una librería con 3 parámetros, dos enteros y un tercero que nos indicara la operación a realizar suma o resta  seria mas sencillo para intentar enctender?
Logged

Palencia, Spain
Offline Offline
God Member
*****
Karma: 25
Posts: 508
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Mira a ver si entiendes este ejemplo de botoncito virtual:

sketch:
Code:
#include "botones.h"
boton miBoton(20,10,80,30,"Mi boton");
void setup() {
      miBoton.pinta();
      miBoton.setFuente(2);
      miBoton.setModo(3);
      miBoton.pinta();
      Serial.print("el resultado de chequea para las coordenadas 20,20 es: ");
      Serial.println(miBoton.chequea(20,20));
}

void loop() {
  // put your main code here, to run repeatedly:
 
}

botones.h
Code:
#ifndef botones_h
#define botones_h
#include <Arduino.h>
class boton{
      private:
        int posX1, posY1, posX2, posY2;                                          // Coordenadas del botón
        String texto;                                                            // Texto del botón
        int fuente, modo;                                                    // fuente y modo de destello, ambas por defecto 1
      public:
        boton(int x1, int y1, int x2, int y2, String txt);                       // Constructor
        void pinta(void);                                                        // Dibuja botones
        void setFuente(int nuevaFuente);                                         // cambie la fuente del botón
        void setModo(int nuevoModo);                                             // cambia modo de destello
        int chequea(int x, int y);                                               // chequea si unas coordenadas pertenecen al botón
};
#endif

botones.cpp
Code:
#include "botones.h"
boton::boton(int x1, int y1, int x2, int y2, String txt)
{
      posX1=x1;
      posY1=y1;
      posX2=x2;
      posY2=y2;
      texto=txt;
      fuente=1;
      modo=1;
}

void boton::pinta(void)
{
      Serial.print("Estoy dibujando un boton en las coordenadas ");
      Serial.print(posX1);
      Serial.print(",");
      Serial.print(posY1);
      Serial.print(" - ");
      Serial.print(posX2);
      Serial.print(",");
      Serial.print(posY2);
      Serial.print("Tipo de letra: ");
      Serial.println(fuente);
      Serial.print("Modo de parpadeo: ");
      Serial.println(modo);
}

void boton::setFuente(int nuevaFuente)
{
      if (nuevaFuente>=1 && nuevaFuente<=2)
      {
            fuente=nuevaFuente;
      }
}

void boton::setModo(int nuevoModo)
{
      if (nuevoModo>=1 && nuevoModo<=3)
      {
            modo=nuevoModo;
      }
}

int boton::chequea(int x, int y)
{
      return(x>=posX1 && y>=posY1 && x<=posX2 && y<posY2);
}

Logged

Vilalba, Lugo, Spain
Offline Offline
Sr. Member
****
Karma: 23
Posts: 336
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Aquí tienes el .h intente meter todos los parámetros en una estructura para simplificar un poco y evitar errores, no se si es correcto o no. Incluí también los datos de la pantalla  para poder definir la en la librería , no se si es necesario

Code:
#ifndef botones_h
#define botones_h
#include <Arduino.h>                      

struct Color  {int R; int G; int B;};
struct Coordenada { int X1; int Y1; int X2; int Y2; };
struct Conexion_P {byte Model; int RS; int WR; int CS; int RST;};
struct Conexion_T {int TCLK; int TCS; int TDIN; int TDOUT; int IRQ;};
struct Parametros
{    
  Conexion_P C_Pantalla;// Pines de conexion a pantalla
  Conexion_T C_Tactil;  // Pines de conexion a sensor tactil
  Coordenada Posicion;  // Posicion del marco que contendra los botones
  Color      C_Marco;   // Color del marco
  Color      C_BotonA;  // Color del boton si esta activo
  Color      C_BotonD;  // Color del boton si esta desactivo
  Color      C_Aro;     // Color del aro interior del boton si esta activo
  Color      C_Texto;   // Color del texto de boton
  int Filas;            // Numero de filas de botones
  int Columnas;         // Numero de columnas de botones
  int Separacion;       // Separacion minima entre marco y botones
  int Fuente;           // 8x12 16x16   1 o 2
  String Texto[];       // Texto de los botones
  bool Estado[];        // Acitivo o desactivo
  int Modo[];           // Modo de parpadeo del aro de boton
};
class Boton
{
  private:
  Parametros p_Boton;
  public:
    Boton(Parametros P_Boton);    // constructor  
    
    void Pinta_Botones(void);     // Método que dibuja todos los botones
    void Pinta_Boton(int b);      // Método que dibuja un solo boton
    void Activa_Boton(void);      // Método activa/desactiba un boton    
    int Boton_Pulsado();          // Método que devuelve el numero de boton pulsado o -1
    bool Boton_Activo(int b);     // Metodo que devuelve si el boton b esta activo o no
};
#endif  

en el .cpp tengo mas problemas, no tengo ni idea de como y donde definir la pantalla que usa. solo incluí el primer método, para ver fallos llegara no?

Code:
#include "Botones.h"
#include <UTFT.h>                           // Pantalla TFF
#include <UTouch.h>                         // Tactil      
extern uint8_t SmallFont[];                 // Fuente Pequeña
extern uint8_t BigFont[];                   // Fuente mediana


Boton::Boton(Parametros P_Boton)
{
  p_Boton=P_Boton;
  UTFT Pantalla(P_Boton.C_Pantalla.Model, P_Boton.C_Pantalla.RS, P_Boton.C_Pantalla.WR, P_Boton.C_Pantalla.CS, P_Boton.C_Pantalla.RST); // Conexion con la pantalla
  UTouch Tactil(P_Boton.C_Tactil.TCLK, P_Boton.C_Tactil.TCS, P_Boton.C_Tactil.TDIN, P_Boton.C_Tactil.TDOUT, P_Boton.C_Tactil.IRQ);      // Conexion conel sensor tactil
}
 
void Boton::Pinta_Botones(void)
{
  int X1,Y1,X2,Y2;                                                                                           // Coordenadas iniciales de cada boton y de cada texto
  int tX,tY;                                                                                                 // Dimension x e y del botones
  int Tx,Ty;                                                                                                 // Dimensiones x e y de cada texto
  int Boton=0;                                                                                               // Contador para carteles de boton
  Pantalla.setColor(p_Boton.C_Marco.R,p_Boton.C_Marco.G,p_Boton.C_Marco.B);                                  // Color marco  
  Pantalla.fillRoundRect (p_Boton.Posicion.X1,p_Boton.Posicion.Y1,p_Boton.Posicion.X2,p_Boton.Posicion.Y2);  // Borrar sitio botones  
  tX=((p_Boton.Posicion.X2-p_Boton.Posicion.X1)-(p_Boton.Columnas + 1)*p_Boton.Separacion)/p_Boton.Columnas; // Longitud X de los botones
  tY=((p_Boton.Posicion.Y2-p_Boton.Posicion.Y1)-(p_Boton.Filas + 1)*p_Boton.Separacion)/p_Boton.Filas;       // Longitud Y de los botones
  for (int C=0; C<p_Boton.Columnas; C++)                                                                     // Recorrer columnas
  {
    X1= p_Boton.Posicion.X1 + p_Boton.Separacion + ( tX + p_Boton.Separacion ) * C;                          // Calcular coordenada X1
    for (int F=0; F<p_Boton.Filas; F++)                                                                      // Recorrer filas
    {  
      Y1= p_Boton.Posicion.Y1 + p_Boton.Separacion + ( tY + p_Boton.Separacion ) * F;                        // Calcular coordenada Y1
      if (p_Boton.Estado[Boton])                                                                             // Color boton si activo  
      {
        Pantalla.setColor(p_Boton.C_BotonA.R,p_Boton.C_BotonA.G,p_Boton.C_BotonA.B);                        
        Pantalla.setBackColor(p_Boton.C_BotonA.R,p_Boton.C_BotonA.G,p_Boton.C_BotonA.B);
      }                          
      else                                                                                                   // Color boton si desactivo
      {
        Pantalla.setColor(p_Boton.C_BotonD.R,p_Boton.C_BotonD.G,p_Boton.C_BotonD.B);
        Pantalla.setBackColor(p_Boton.C_BotonD.R,p_Boton.C_BotonD.G,p_Boton.C_BotonD.B);
      }        
      Pantalla.fillRoundRect(X1,Y1,X1+tX,Y1+tY);                                                             // Fondo del boton
      Pantalla.setColor(0,0,0);                                                                              // Color negro para aro boton
      for (int I=2; I<5;I++){Pantalla.drawRoundRect(X1+I, Y1+I, X1+tX-I, Y1+tY-I);}                          // Aro de boton    
      if (p_Boton.Fuente==1)                                                                                 // Fuente pequeña
      {
        Pantalla.setFont(SmallFont);                                                                         // Establecer fuente
        Tx=8*p_Boton.Texto[Boton].length();                                                                  // Tamaño X cartel
        Ty=12;                                                                                               // Tamaño y cartel
      }
      else                                                                                                   // Fuente mediana
      {
        Pantalla.setFont(BigFont);                                                                           // Establecer fuente
        Tx=16*p_Boton.Texto[Boton].length();                                                                 // Tamaño X cartel
        Ty=16;                                                                                               // Tamaño y cartel
      }
      Pantalla.setColor(p_Boton.C_Texto.R,p_Boton.C_Texto.G,p_Boton.C_Texto.B);                              // Color Texto
      Pantalla.print(p_Boton.Texto[Boton],X1+(tX-Tx)/2, Y1+(tY/2)-(Ty/2));                                   // Poner el cartel centrado al boton
      Boton++;                                                                                               // Siguiente cartel
    }
  }
}    

No pude comprobar nada por que me da errores de compilación, no existe pantalla
Logged

Palencia, Spain
Offline Offline
God Member
*****
Karma: 25
Posts: 508
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

¡Hala! ¡Alegría!  smiley
Me dices que retrocedamos a algo sencillo y luego te tiras al pozo con todo, metiendo una estructura dentro de otra (una clase ya es de por sí una estructura) "para simplificar"  smiley-eek-blue.  Por supuesto que se puede, aunque esto estaba previsto para más adelante, cuando ya conozcas las posibilidades que te puede brindar la programación orientada a objetos, y hayas planificado definitivamente tu librería.
Las clases son prácticamente estructuras de por sí, pero con unos cuantos añadidos:
- Tienen, además de variables (propiedades) de esa estructura, funciones (métodos) que trabajan con ellas, sirviendo como "puertas" de entrada/manejo/salida (interfaz), que es lo que interesará al futuro usuario de esas clases, despreocupándose de los quebraderos de cabeza que se haya dado el creador para lograr que funcione.
- Mediante palabras claves (private, protected, public) se pueden encapsular, para proteger lo que tienen dentro. Por ejemplo, podríamos dejar que se puedan modificar directamente las variables de coordenadas del botón, pero si hemos creado un método para hacerlo con control de errores (por ejemplo evitar que las coordenadas queden fuera de la pantalla), pondremos esas coordenadas en la sección private, "obligando" a usar nuestra función, evitando que se toqueteen al libre albedrío.
- Podemos reutilizar una clase, para crear otra nueva, añadiendo o modificando propiedades o métodos de la primera (herencia). Por ejemplo, podríamos ampliar la clase UTFT y crear MYTFT, añadiéndole las funciones para crear y gestionar botones.
- Y (esto es un poco más complicado de entender) podemos crear varios herederos de una clase base con un método que se llame igual y se comporte de forma diferente según el tipo de heredero que sea. Por ejemplo, podemos crear una clase base Boton, y las derivadas BotonCuadrado y BotonRedondo (cada una tendrá un método pinta diferente). Luego podríamos crear un array Boton miarraybotones[20], y la instrucción miarraybotones[2].pinta() utilizará el método adecuado(cuadrado o redondo) al tipo de botón que corresponda.

Esta era, aproximadamente la senda de aprendizaje por la que te quería llevar. Veo, sin embargo, que tu punto de mira está más puesto en cómo pasar estructuras o arrays a funciones, así que intentaré saciar tu curiosidad, a la par que te "cuelo" alguna cosilla de programación orientada a objetos, y departimos sobre distintas posibilidades para llegar al resultado. No me hago responsable si luego descubres otras formas que te puedan parecer mejores y te toca rehacer cosas (de hecho yo tampoco lo tengo claro  smiley-roll-sweat).
Logged

Palencia, Spain
Offline Offline
God Member
*****
Karma: 25
Posts: 508
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

¡Vamos allá, entonces! Tomaremos tu camino.
Primeramente, he de decirte que, tristemente, yo no tengo tu pantalla, así que voy a ciegas. Te envío un código que al menos a mí me compila correctamente, basado en lo que has puesto tú anteriormente, pero que muy probablemente no funcione, ya que no está probado. A tí te toca intentar entenderlo y depurarlo para que funcione. Intentaré prestarte ayuda y solventarte las dudas que se te vayan presentando (y de paso crearte algunas nuevas  smiley-evil).

botones.h:
 
Code:
#ifndef botones_h
#define botones_h
#include <Arduino.h>                      
#include <UTFT.h>                           // Pantalla TFF
#include <UTouch.h>                         // Tactil  
 
struct Color  {int R; int G; int B;};
struct Coordenada { int X1; int Y1; int X2; int Y2; };
 
//struct Conexion_P {byte Model; int RS; int WR; int CS; int RST;};
//struct Conexion_T {int TCLK; int TCS; int TDIN; int TDOUT; int IRQ;};
struct Parametros
{    
// Conexion_P C_Pantalla;// Pines de conexion a pantalla
// Conexion_T C_Tactil;  // Pines de conexion a sensor tactil
  Coordenada Posicion;  // Posicion del marco que contendra los botones
  Color      C_Marco;   // Color del marco
  Color      C_BotonA;  // Color del boton si esta activo
  Color      C_BotonD;  // Color del boton si esta desactivo
  Color      C_Aro;     // Color del aro interior del boton si esta activo
  Color      C_Texto;   // Color del texto de boton
  int Filas;            // Numero de filas de botones
  int Columnas;         // Numero de columnas de botones
  int Separacion;       // Separacion minima entre marco y botones
  int Fuente;           // 8x12 16x16   1 o 2
  String *Texto;       // Texto de los botones
  bool *Estado;        // Acitivo o desactivo
  int *Modo;           // Modo de parpadeo del aro de boton
};
 
class Boton
{
  private:
    Parametros &_P_Boton;
    UTFT &_Pantalla;       // La pantalla y táctil los iniciamos aparte
    UTouch &_Tactil;       // y pasamos referencia.
  public:
    Boton(Parametros &P_Boton, UTFT &Pantalla, UTouch &Tactil);    // constructor  
    
    void Pinta_Botones(void);     // Método que dibuja todos los botones
    void Pinta_Boton(int b);      // Método que dibuja un solo boton
    void Activa_Boton(void);      // Método activa/desactiba un boton    
    int Boton_Pulsado();          // Método que devuelve el numero de boton pulsado o -1
    bool Boton_Activo(int b);     // Metodo que devuelve si el boton b esta activo o no
};
#endif  

botones.cpp
 
Code:
#include "Botones.h"
  
extern uint8_t SmallFont[];                 // Fuente Pequeña
extern uint8_t BigFont[];                   // Fuente mediana
 
 
Boton::Boton(Parametros &P_Boton, UTFT &Pantalla, UTouch &Tactil):_P_Boton(P_Boton),_Pantalla(Pantalla),_Tactil(Tactil)
{
 
}
 
void Boton::Pinta_Botones(void)
{
  int X1,Y1;                                                                                           // Coordenadas iniciales de cada boton y de cada texto
  int tX,tY;                                                                                                 // Dimension x e y del botones
  int Tx,Ty;                                                                                                 // Dimensiones x e y de cada texto
  int Boton=0;                                                                                               // Contador para carteles de boton
  _Pantalla.setColor(_P_Boton.C_Marco.R, _P_Boton.C_Marco.G, _P_Boton.C_Marco.B);                                  // Color marco  
  _Pantalla.fillRoundRect (_P_Boton.Posicion.X1,_P_Boton.Posicion.Y1,_P_Boton.Posicion.X2,_P_Boton.Posicion.Y2);  // Borrar sitio botones  
  tX=((_P_Boton.Posicion.X2-_P_Boton.Posicion.X1)-(_P_Boton.Columnas + 1)*_P_Boton.Separacion)/_P_Boton.Columnas; // Longitud X de los botones
  tY=((_P_Boton.Posicion.Y2-_P_Boton.Posicion.Y1)-(_P_Boton.Filas + 1)*_P_Boton.Separacion)/_P_Boton.Filas;       // Longitud Y de los botones
  for (int C=0; C<_P_Boton.Columnas; C++)                                                                     // Recorrer columnas
  {
    X1= _P_Boton.Posicion.X1 + _P_Boton.Separacion + ( tX + _P_Boton.Separacion ) * C;                          // Calcular coordenada X1
    for (int F=0; F<_P_Boton.Filas; F++)                                                                      // Recorrer filas
    {  
      Y1= _P_Boton.Posicion.Y1 + _P_Boton.Separacion + ( tY + _P_Boton.Separacion ) * F;                        // Calcular coordenada Y1
      if (_P_Boton.Estado[Boton])                                                                             // Color boton si activo  
      {
        _Pantalla.setColor(_P_Boton.C_BotonA.R,_P_Boton.C_BotonA.G,_P_Boton.C_BotonA.B);                        
        _Pantalla.setBackColor(_P_Boton.C_BotonA.R,_P_Boton.C_BotonA.G,_P_Boton.C_BotonA.B);
      }                          
      else                                                                                                   // Color boton si desactivo
      {
        _Pantalla.setColor(_P_Boton.C_BotonD.R,_P_Boton.C_BotonD.G,_P_Boton.C_BotonD.B);
        _Pantalla.setBackColor(_P_Boton.C_BotonD.R,_P_Boton.C_BotonD.G,_P_Boton.C_BotonD.B);
      }        
      _Pantalla.fillRoundRect(X1,Y1,X1+tX,Y1+tY);                                                             // Fondo del boton
      _Pantalla.setColor(0,0,0);                                                                              // Color negro para aro boton
      for (int I=2; I<5;I++){_Pantalla.drawRoundRect(X1+I, Y1+I, X1+tX-I, Y1+tY-I);}                          // Aro de boton    
      if (_P_Boton.Fuente==1)                                                                                 // Fuente pequeña
      {
        _Pantalla.setFont(SmallFont);                                                                         // Establecer fuente
        Tx=8*_P_Boton.Texto[Boton].length();                                                                  // Tamaño X cartel
        Ty=12;                                                                                               // Tamaño y cartel
      }
      else                                                                                                   // Fuente mediana
      {
        _Pantalla.setFont(BigFont);                                                                           // Establecer fuente
        Tx=16*_P_Boton.Texto[Boton].length();                                                                 // Tamaño X cartel
        Ty=16;                                                                                               // Tamaño y cartel
      }
      _Pantalla.setColor(_P_Boton.C_Texto.R,_P_Boton.C_Texto.G,_P_Boton.C_Texto.B);                              // Color Texto
      _Pantalla.print(_P_Boton.Texto[Boton],X1+(tX-Tx)/2, Y1+(tY/2)-(Ty/2));                                   // Poner el cartel centrado al boton
      Boton++;                                                                                               // Siguiente cartel
    }
  }
}    

Y finalmente un pequeño sketch de prueba. Como ves, la complejidad de parámetros que quitamos del constructor la hemos traspasado a la creación de la estructura, así que tampoco es que hayamos simplificado mucho  smiley-confuse.
sketch
Code:
#include <UTFT.h>
#include <UTouch.h>
#include "botones.h"
 
UTFT Pantalla(5, 11, 12, 13, 14); // Conexion con la pantalla
UTouch Tactil(1,2,3,4,5);
 
String textoBotones[]={"Texto1", "Texto2", "Texto3", "Texto4"};
bool parpadeoBotones[]={true,false,false,true};
int estiloBotones[]={1,2,1,1};
 
Parametros miRejilla={
  {10,10,300,200},  // Posicion del marco que contendra los botones
  {10,10,10},   // Color del marco
  {0,0,0},      // Color del boton si esta activo
  {255,0,250},  // Color del boton si esta desactivo
  {90,60,90},   // Color del aro interior del boton si esta activo
  {10,10,10},   // Color del texto de boton
  4,            // Numero de filas de botones
  1,            // Numero de columnas de botones
  1,            // Separacion minima entre marco y botones
  1,            // 8x12 16x16   1 o 2
  textoBotones,       // Texto de los botones
  parpadeoBotones,     // Acitivo o desactivo
estiloBotones         // Modo de parpadeo del aro de boton
};
 
Boton misBotones(miRejilla,Pantalla,Tactil);
 
void setup(void){
        misBotones.Pinta_Botones();
}
 
 
void loop(void){
}

EDITO: con lo que yo sí habría creado una estructura defBoton es con los datos texto, parpadeo y estilo, y así, en lugar de
String texto[];
bool estado[];
int modo[];
dejaría
defBoton datosBotones[];
Así me aseguro de que al menos tengo el mismo número de textos, estados y modos.

« Last Edit: December 19, 2013, 06:00:10 pm by noter » Logged

Vilalba, Lugo, Spain
Offline Offline
Sr. Member
****
Karma: 23
Posts: 336
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Buenas noter, no he podido probar todavía, la ultima tormenta ha decidido que no realice ensayos en una  temporada   smiley-cry

Ayer he conseguido un "conector" para enchufar un disco ide a un puerto usb, a ver si consigo rescatar algo. en cuanto recupere mis ficheros me pongo al dia.

Por cierto, tienes razón, los parámetros hay que amontonarlos en algún lado.

Perdona por pedir una paso a tras y dar dos adelante, solo creí haber entendido algo que no había entendido antes. En rasgos generales, el concepto lo tengo claro, me falla la gramática. Y por supuesto tengo claro que siempre existe una manera mejor de hacer algo.

Por cierto, corrígeme si me equivoco, pero al formar una estructura con texto, parpadeo, etc, sol,o garantizas tener el mismo numero de parámetros de cada tipo si dimensionas los  vectores, cosa que no deveriamos hacer por que no conecemos el numero de e...   smiley-roll-sweat ...lo pensé mejor, creando un vector con la estructura si lo garantizas, jejeje. aun que solo garantizas tener en numero de elementos, no que estén llenos.

PD. que feliz era cuando las variables con un mismo nombre eran las mismas, y los bloques de instrucciones se amontonaban felizmente unas sobre otras en sub rutinas, y las sub rutinas tenían cada una su nombre y apellidos... No se quien dijo que la ignorancia provocaba felicidad  smiley
Logged

Pages: 1 2 [3]   Go Up
Jump to: