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

UTouchCD.h original:

#define CAL_X 0x00378F66UL
#define CAL_Y 0x03C34155UL
#define CAL_S 0x000EF13FUL

UTouchCD.h editado:

#define CAL_X 0x00174FB3
#define CAL_Y 0x00414F4E
#define CAL_S 0x8031F1DF

No tengo claro si el error eran los valores o el sufijo, pero probare a ponerle el sufijo de nuevo y ya te contare
Logged

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

No vi diferencia entre ponerle y no ponerle el sufijo
Logged

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

Bueno. Sea como fuere, bien está lo que bien acaba smiley-wink
Enhorabuena.
Logged

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

Bueno, una vez funcionando, hay que sacarle el polvo a la pantalla. Acabe una par de funciones para manejar botones, por si alguien le interesa la cuelgo, esta pensada para hacer menus  de botones con comodidad.
este pinta los botones
Code:
//  ***************************************************************************************************************
//  ***************************************************************************************************************
//  *** DIBUJA MARCO Y BOTONES EN EL,CENTRA HORIZONTAL Y VERTICAL MENTE  TANTO EL BOTON COMO EL CARTE DEL MISMO ***
//  *** Parametros:                                                                                             ***
//  *** MarcoX1, MarcoX2, MarcoX2, MarcoY2 coordenadas x e y del marco destiando a los botones (area a limpiar) ***
//  *** Texto[] vector con los nombres a poner en los botones (no controla que la cantidad coincida)            *** 
//  *** Fuente  Fuente a usr para e texto del boton 8x12 16x16   (1 o 2)                                        ***
//  *** Filas, Columnas   Numero de filas y columnas de botones a pintar                                        ***
//  *** Separacion separacion minima entre marcos y botones                                                     ***
//  *** No controla que el texto coja en el boton ni que los botones cojan en el marco                          ***
//  *** Ojo, controlar color, color fondo y fuente al regresar                                                  ***
//  ***************************************************************************************************************
// *********************************************************************** // *************************************
void  PintaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion)
{                                                                       
  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 Cartel=0;                                                            // Contador para carteles de boton
  Pantalla.setBackColor(0,0,0);                                            // Fondo negro
  Pantalla.setColor(0,0,0);                                                // Color negro
  Pantalla.fillRoundRect (MarcoX1, MarcoY1, MarcoX2, MarcoY2);             // Borrar sitio botones
  Pantalla.setColor(255,255,255);                                          // Color blanco
  Pantalla.drawRoundRect (MarcoX1, MarcoY1, MarcoX2, MarcoY2);             // Marco de botones
  tX=((MarcoX2-MarcoX1) - (Filas + 1)*Separacion) / Filas;                 // Longitud X de los botones
  tY=((MarcoY2-MarcoY1) - (Columnas + 1)*Separacion) / Columnas;           // Longitud Y de los botones
  for (int C=0; C<Columnas; C++)                                           // Recorrer columnas
  {
    Y1= MarcoY1 + Separacion + ( tY + Separacion ) * C;                    // Calcular coordenada Y1
    for (int F=0; F<Filas; F++)                                            // Recorrer filas
    {   
      X1= MarcoX1 + Separacion + ( tX + Separacion ) * F;                  // Calcular coordenada X1
      Pantalla.drawRoundRect(X1, Y1, X1+tX, Y1+tY);                        // Contorno boton
      Pantalla.setColor(0,0,255);                                          // Color verde
      Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1);                // Marco ineriore de boton
      Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2);                // Marco ineriore de boton
      Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3);                // Marco ineriore de boton
      Pantalla.setColor(255,255,255);                                      // Color blanco
      Pantalla.drawRoundRect(X1+4, Y1+4, X1+tX-4, Y1+tY-4);                // Marco ineriore de boton
      if (Fuente==1)                                                       // Fuente pequeña
      {
        Pantalla.setFont(SmallFont);                                       // Establecer fuente
        Tx=8*Texto[Cartel].length();                                       // Tamaño X cartel
        Ty=12;                                                             // Tamaño y cartel
      }
      else                                                                 // Fuente mediana
      {
        Pantalla.setFont(BigFont);                                         // Establecer fuente
        Tx=16*Texto[Cartel].length();                                      // Tamaño X cartel
        Ty=16;                                                             // Tamaño y cartel
      }
      Pantalla.print(Texto[Cartel],X1 + (tX-Tx)/2 ,Y1+(tY/2)-(Ty/2) );     // Poner el cartel centrado al boton
      Cartel++;                                                            // Siguiente cartel
    }
  }
}


Alguien me puede decir si es posible meter en una estructura o en una variable todos los parametros para hacer la escritura mas facil?

void  PintaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion)
Logged

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

Y este comprueba cual pulsas

Code:
//  ***************************************************************************************************************
//  ***************************************************************************************************************
//  *** COMPRUEBA QUE SI HAY PULSACION EL EL SENSOR TACTIL Y RETORNA EN NUMERO DEL BOTON AL QUE CORRESPONDE O 0 ***
//  *** Parametros:                                                                                             ***
//  *** MarcoX1, MarcoX2, MarcoX2, MarcoY2 coordenadas x e y del marco destiando a los botones                  ***
//  *** Filas, Columnas   Numero de filas y columnas de botones a pintar                                        ***
//  *** Separacion separacion minima entre marcos y botones                                                     ***
//  ***  MODO: 1 = Destello continuo hasta soltar, 2 = un destello completo y se sale, 3 = un solo destello     ***
//  *** Ojo, controlar color, color fondo al regresar                                                           ***
//  ***************************************************************************************************************
// *********************************************************************** // *************************************
int  ChequeaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, int Filas, int Columnas, int Separacion, int Modo )
{
  int PX,PY;                                                               // Coordenadas Pulsadas
  int X1,Y1,X2,Y2;                                                         // Coordenadas iniciales de cada boton y de cada texto
  int tX,tY;                                                               // Dimension x e y del botones
  int Rojo=255;                                                            // Color del marco boton
  int Opc=0;                                                               // Numero de boton pulsado
  Tactil.read();                                                           // Obtener Coordenada pulsada
  PX=Tactil.getX();                                                        // Coordenada x
  PY=Tactil.getY();                                                        // Coordenada y
  if (PX>-1 && PY>-1)                                                      // Hay coordenada pulsada
  {
    tX=((MarcoX2-MarcoX1) - (Filas + 1)*Separacion) / Filas;               // Longitud X de los botones
    tY=((MarcoY2-MarcoY1) - (Columnas + 1)*Separacion) / Columnas;         // Longitud Y de los botones
    for (int C=0; C<Columnas; C++)                                         // Recorrer columnas
    {
      Y1= MarcoY1 + Separacion + ( tY + Separacion ) * C;                  // Calcular coordenada Y1
      for (int F=0; F<Filas; F++)                                          // Recorrer filas
      {   
        X1= MarcoX1 + Separacion + ( tX + Separacion ) * F;                // Calcular coordenada X1
        if (PX>=X1 && PX<=X1+tX && PY>=Y1 && PY<=Y1+tY)                    // Pinchamos dentro de un boton
        {
          while (Tactil.dataAvailable() && Rojo>0)                         // Mientras mantenemos pulsado y hay color
          { 
            Pantalla.setColor(Rojo,0,0);                                   // Color  rojo variable en funcion del tiempo
            Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1);          // Marco ineriore de boton
            Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2);          // Marco ineriore de boton
            Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3);          // Marco ineriore de boton
            Rojo=Rojo-10;                                                  // Bajando intensidad rojo
            if (Modo==3) {Rojo=-1;}                                        // Modo 3 solo pinta 1 vez marco 
            else if (Modo==1 && Rojo<1){Rojo=255;}                         // Modo 1 Destello continuo, modo 2 para solo con rojo<0     
          }
          Pantalla.setColor(0,0,255);                                      // color azul
          Pantalla.drawRoundRect(X1+1, Y1+1, X1+tX-1, Y1+tY-1);            // Marco ineriore de boton
          Pantalla.drawRoundRect(X1+2, Y1+2, X1+tX-2, Y1+tY-2);            // Marco ineriore de boton
          Pantalla.drawRoundRect(X1+3, Y1+3, X1+tX-3, Y1+tY-3);            // Marco ineriore de boton
          Pantalla.setColor(255,255,255);                                  // color blanco
          Opc= C*Filas + F + 1;                                            // Boton pulsado
          F=Filas+1;                                                       // Finalizar bucle filas
          C=Columnas+1;                                                    // Finalizar bucle columnas
        }
      }
    }   
  }                                                 
  return Opc; 
}
Logged

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

. . . . . . . .

Alguien me puede decir si es posible meter en una estructura o en una variable todos los parametros para hacer la escritura mas facil?

void  PintaBotones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion)

Interesantísima pregunta. De una inquietud similar nació lo que se conoce como Programación Orientada a Objetos. Podrías crear una librería con una clase de objeto botón y sus correspondientes métodos dibuja() y chequea(), de forma que una vez realizado el include correspondiente podrías utilizar más o menos de una forma similar a:

boton miBoton1(x1,y1,x2,y2,texto,etc);
boton miBoton2((x1,y1,x2,y2,texto,etc);
miBoton1.dibuja();
miBoton2.dibuja();
if (miBoton1.pulsado()) funcion1();
if(miBoton2.pulsado()) funcion2();

Si quieres hacerlo así, desde aquí te podemos dar algún empujoncillo.
Logged

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

Eso seria muy interesante,  pero para mi es "terreno pantanoso", en cuestión de POO llegue a medio entender, pero no tengo ni idea de como crear librería.

Si te animas a explicarme, te advierto que necesitare preguntar bastante...
Logged

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

Bien entonces. Vamos al lío.
Realmente no es en principio nada complicado crear esa librería, pero en lugar de darte el trabajo hecho, aunque incluso para mí sería lo más rápido y sencillo, creo que te será más productivo que te guíe (y de paso pueda servir a alguno más) para que no sólo tengas tu librería, sino que puedas ampliarla y crear otras en un futuro.
Te explico cómo suelo crearlas yo.
Partimos de crear un proyecto nuevo (o puedes partir de donde tienes las funciones, pues mucho del trabajo será copia-pega).
Al principio del código vamos a poner el include de la futura librería, de momento con comillas:
#include "Botones.h"
Ahora vamos a crear ese archivo: pulsamos el botón de nueva pestaña (una flechita en la parte superior derecha del editor). Nos pedirá nombre para dicha pestaña, que será exactamente el mismo que hayamos puesto en el include (Botones.h).
Vamos a la pestaña recien creada, y ahí vamos a definir el "esqueleto" de nuestras clases. Lo primero, es buena costumbre para evitar la posibilidad de que se incluya el archivo más de una vez, definir una estructura para el preprocesador de la siguiente forma:
#ifndef botones_h
#define botones_h
// Aquí irá el código de definición de nuestra librería.
#endif
Dentro de esa estructura definiremos nuestra/s clase/s con todas sus propiedades (variables) y métodos (funciones). Por ejemplo, y aunque a buen seguro no tenga nada que ver con tu idea de los objetos que tú tengas en mente:
Code:
#ifndef botones_h
#define botones_h

// Ancho y alto por defecto de botón
#define ANCHODEFECTO 100
#define ALTODEFECTO 50

class boton
{
private:
      int x1, y1, x2, y2; // esquinas del botón
      char *texto; // texto del botón
public:
      boton(int left, int top, int right, int bottom); // constructor
      boton(int left, int top); // constructor de botón de ancho estándar
      void pinta(void); // Método que dibuja el botón
      bool contiene(int x, int y); // Método que devuelve true si unas coordenadas están dentro del botón
};    // Aquí es importante recordar que hay que poner punto y coma tras la definición de la clase
#endif

Esto sería nuestro boton.h, en principio. Hasta el momento, como verás, no hemos puesto ni una línea de código, pero ojeando la definición de nuestra clase nos indica bastante bien cómo se van a utilizar los objetos que creemos con ella, y el trabajo que nos queda por hacer en nuestro archivo .cpp. Lo dejaremos de momento para otro post.
Ahora es tu turno.
¿Qué propiedades (variables) tendría la clase que quieres crear? ¿Y qué funciones (métodos) debería poder realizar?
¿Te atreves a crear un .h con ello?
Logged

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

Quien dijo miedo habiendo hospitales  smiley

Code:
#ifndef botones_h
#define botones_h
class boton
{
  private:
    struct Color  // Valores rgb para los colores
    {
      int R;
      int G;
      int B;
    };
    struct Posicion  // Coordendas xy iniciales y finales
    {
      int X1;
      int Y2;
      int X2;
      int Y2;
    };
  public:
    struct Boton
    {
      struct Posicion P_Marco;    // Coordenadas xy del marco que contendra los botones
      struct Color    C_Marco;    // Color del marco
      struct Color    F_Marco;    // Color del fondo
      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[];             // Carteles de lso botones
      boolean Estado[];           // Acitivo o desactivo
      int Modo[];                 // Modo de parpadeo del aro de boton
      struct Color    C_Boton;    // Color del marco de boton
      struct Color    F_Boton;    // Color del fondo de boton
      struct Color    A_Boton;    // Color del aro de boton
      struct Color    T_Boton;    // Color del texto de boton     
    };
    void Pinta_Botones(void);     // Método que dibuja todos los botones
    void Activa_Boton(void);      // Método activa/desactiba boton   
    int Pulsado();                // Método que devuelve el numero de boton pulsado o -1
    bool Activo(int b);           // Metodo que devuelve si el boton b esta activo o no
#endif
Logged

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

Pues nada smiley-wink ¿quién dijo miedo?
Repasando tu código inicial, vamos depurando por partes.
Lo primero, cuando defines una clase, estás definiendo una estructura, así que no es necesario que incluyas más estructuras dentro, salvo para simplificar. Un buen ejemplo pueden ser la estructura color, que se va a repetir varias veces en tu clase, pero además te va a ser de utilidad para el programa que vaya a usar esta clase. Por lo tanto, las definiremos fuera de la clase.
Creo que no tienes muy claro aún qué significan las secciones private y public de un objeto. Resumiendo, todo lo que esté en la sección private sólo va a poder ser accedido por el propio objeto. Por ejemplo, si guardas en private la posición, color, etc... no podrás modificarlos directamente desde fuera, y deberás crear en la sección public funciones que modifiquen dichos parámetros (setColor, mueveBotón...). Si lo dejas en la sección pública, podrás modificarlas directamente con comandos estilo objeto.x1=100, pero será más fácil que puedas realizar cambios no deseados. Tú decides entre dejar al exterior manejar todo o que el propio objeto controle qué y cómo se puede manejar.
Te falta en la clase una o varias funciones importantísimas, que se llaman igual que la propia clase y se conocen como constructores y su misión es esa: construir un objeto de esa clase. Puedes definir varios, con distinto número de parámetros. Por ejemplo uno con 6 parámetros (4 de posición+filas+columnas), otro con 4 parámetros (las filas y columnas van a ser un número por defecto) e incluso uno sin parámetros (todo será por defecto).
Éste sería un código modificado. Mira a ver si echas algo de menos o si tienes alguna duda sobre lo escrito. Mañana comenzamos a introducir código.
Code:
#ifndef botones_h
#define botones_h
#include <Arduino.h>  // Si no incluyo esto, no se reconoce el objeto String en este archivo.

struct Color  // Estructura de apoyo. Valores rgb para los colores
{
      int R;
      int G;
      int B;
};

class botones
{
  private:
      int X1;
      int Y1;
      int X2;
      int Y2;
      Color    C_Marco;    // Color del marco
      Color    F_Marco;    // Color del fondo
      Color    C_Boton;    // Color del marco de boton
      Color    F_Boton;    // Color del fondo de boton
      Color    A_Boton;    // Color del aro de boton
      Color    T_Boton;    // 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[];      // Carteles de lso botones
      bool Estado[];       // Acitivo o desactivo
      int Modo[];          // Modo de parpadeo del aro de boton
  public:
      botones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion); // constructor 1
      botones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente); // constructor 2
      void Pinta_Botones(void);     // Método que dibuja todos los botones
      void Activa_Boton(void);      // Método activa/desactiba boton   
      int Pulsado();                // Método que devuelve el numero de boton pulsado o -1
      bool Activo(int b);           // Metodo que devuelve si el boton b esta activo o no
};
#endif
Logged

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

El constructor es usado para definir una "copia" de la clase que estamos creando?
Faltaria en el constructor incluir el color, se podria utilizar la estructura definida para los colores?
Logged

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

La clase que estás creando es un "molde" del futuro o futuros objetos que crearemos. Para crear cada objeto "moldeado" llamaremos al constructor, que es una función que tiene tiene el mismo nombre que la clase, y al que le pasaremos los parámetros que definamos. Por ejemplo podríamos definir así:
botones miMenu(10,15,100,12, cadenaStrings,...).
El compilador, dependiendo del número y tipo de parámetros buscará el constructor que encaje entre los que hemos definido (si ninguno encaja devolverá error). Podríamos crear por ejemplo un constructor vacío, en el que todos los parámetros van a ser unos prefijados, y bastaría con definir:
botones miMenu();
Después deberemos dar contenido a esos constructores, y en cada uno definir qué variables ponemos con qué valores.
En cuanto a los colores, podrías utilizar esa estructura y pasarla, o incluso definir una estructura que contenga todos los parámetros de la botonera (aunque en algún momento tendrás que poner todos los datos amontonados smiley). En ese caso, lo mejor es pasar los datos por referencia, en lugar de por valor (esto sería válido también para las funciones que habías creado tú). Por ejemplo:
// constructor.
botones(int x1, int y1, int ancho, int largo, color &fondo, color &fuente);

//llamada
color colora={255,255,255}, colorb={128,255,128};
botones miMenu(10,10,10,50, colora,colorb);

O en el caso "salvaje". Definimos una super estructura parametro_botones que contiene todas las variables que incumben al botón. Podríamos pasarla a un constructor:
// constructor
botones(parametro_botones &parametros)

Y llamarla tal que así:

//definición de la estructura
color colorfondo={128, 256, 128}, colorfuente={0,0,0};
parametro_botones mi_preferencia={10, 15, 50, 100, //posición
colorfondo, colorfuente}

//llamada al constructor
botones miMenu(mi_preferencia);

Pero, como te he dicho, en algún lugar tienes que "amontonar" parámetros. La estrategia a seguir depende de tí. De cómo consideres cómo se debería crear un objeto de tu clase. Si, por ejemplo piensas que la mayor parte de las veces va a estar en un sitio determinado, tener el mismo número de filas y columnas, y lo que va a variar es el color, pues puedes definir el constructor para enviarle sólo el color, y después funciones auxiliares setcols o setrows para modificar número de filas/columnas, o setpos para modificar la posición... Como ves, te estoy tocando un poco la moral, pero tenemos (yo también estoy en proceso) que pensar en dividir el problema en objetos, en lugar de en una secuencia de instrucciones; y la planificación tiene casi más importancia que la construcción de las clases. Ya te darás cuenta cuando empieces a pensar "esto sería mejor así" y a modificarla. ¿Pero se trata de aprender?¿No?


Logged

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

Uff, necesite leer 3 veces...  smiley-cry

Creo que te voy entendiendo, dependiendo del uso ira mejor pasar el color como parámetro al constructor o declarar una función que modifique propiedades.

No me tocas la moral en absoluto, he entendido mas en 3 días de lo que llegado a entender con 3 manuales distintos  smiley

botones(int x1, int y1, int ancho, int largo, color &fondo, color &fuente);
el & supongo que es para indicarle que pasar por referencia?

El tema de dividir el problema en objetos, yo creo que es el método mas antiguo del mundomumdial  de solucionar un problema, pero con estética moderna.

Al final se trata no de hacer soluciones, sino mas bien herramientas para la solucion, con la ventaja que las herramientas si estan bien diseñadas valen para mas soluciones.

Yo soy incapaz de hacer un programa, y cuando  esta listo, funcionando y depurado, releerlo y pensar ... Como lo puedo hacer mejor, como se puede optimizar ...

Logged

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

Me alegro de que vayas pillando cosillas. Aunque ahora se te escapen cosas, tienes la ventaja de que una vez que vayas escribiendo código podemos ir directamente a lo que puedes estar haciendo mal y explicar precisamente lo que necesitas, obviando la "paja".
Lo de las referencias es un método de "simplificar" el uso de punteros. Tiene la ventaja y el inconveniente de que en lugar de recibir una copia del valor, recibe la dirección de la variable pasada y funciona como un alias, con lo que si modificamos la variable, estaremos modificando la propia variable pasada. Por ejemplo:
miFuncion(int &x){
    x=-x;
}
void setup(){
    int mi_entero=10;
    miFuncion(mi_entero); // mi_entero pasará a ser -10.
}
Así que para pasar datos grandes es ventajoso, pero debemos tener en cuenta si queremos o no modificar el dato original.
Como lo prometido es deuda, a continuación te explico cómo crear el archivo.cpp. Poco a poco deberías empezar a ver algo en tu pantalla smiley-wink

Logged

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

Pues, como decíamos, vamos a completar el esqueleto de tu aplicación, versión librería.
Primeramente crearemos una nueva pestaña, al igual que hicimos para el archivo.h, pero en esta ocasión el nombre será el mismo, con la extensión .cpp. En esta nueva pestaña vamos a ir dando funcionalidad a lo que habíamos definido en el archivo.h.
Al principio del nuevo archivo pondremos el include de su archivo.h, y como vamos a mover tu pantalla, la librería correspondiente.
Te pongo un código "guía". Está incompleto, y posiblemente mal, ya que no sé exactamente cómo va a funcionar tu clase botones. Su función principal es mostrarte cómo comenzar, y algunas pequeñas cosillas que se pueden hacer (como llamar a un constructor desde otro, o un método desde otro...)
Code:
#include "Botones.h"
#include <Touch.h> // O como quiera que se llame la librería de la pantalla

// Ahora iremos elaborando las funciones que hemos definido en el archivo.h. Las precedemos por el nombre de la clase y dos puntos.
// Lo bueno es que dentro de cada función podemos llamar a las variables y funciones de la clase simplemente por su nombre.

// Constructor "completo" al que le damos todos los parámetros
botones::botones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente, int Filas, int Columnas, int Separacion){
      X1=MarcoX1;
      Y1=MarcoY1;
      etc...
}
// Constructor con menos parámetros. Llamamos al otro constructor, asignando nuestros valores por defecto. Podríamos crear más constructores para distintas situaciones.
botones::botones(int MarcoX1, int MarcoY1, int MarcoX2, int MarcoY2, String Texto[], int Fuente){
      botones(MarcoX1, MarcoY1, MarcoX2, MarcoY2, Texto[], Fuente, 5, 5, 2) // LLamada al constructor "completo" añadiendo los parámetros 5 filas y 5 columnas y separación 2 por defecto.
}

void botones::PintaBotones(void){
      Pantalla.setBackColor(0,0,0);                        // Fondo negro
      Pantalla.setColor(0,0,0);                            // Color negro
      Pantalla.fillRoundRect (X1, Y1, X2, Y2);             // Usamos las variables que definimos para el objeto. Aunque estén en la sección private nos dejará tocarlas desde aquí.
      etc...
}

bool botones::Activo(int b){
      return(Estado[b]);
}

void botones::Activa_Boton(int b){
      Estado[b]=!Estado[b];
      PintaBotones();            //Llamo a la función de dibujado para representar el nuevo estado.
}

// Continuaremos desarrollando el desarrollo del resto de métodos.

Ahora deberías tener tres pestañas: una de proyecto, otra con archivo.h y otra con archivo.cpp. Un código en tu proyecto tan sencillo como:

Code:
#include "Botones.h"
String jj[]={"cadena1",· "cadena2", etc};
botones rejilla(5,2,3,6, jj,3); // los parámetros que necesite tu constructor
void setup(void)
{
      rejilla.Pinta_Botones();
}

debería darte la salida por pantalla.
¿Dónde está la ventaja?
Podrías, por ejemplo, definir rejilla1, rejilla2, etc. y pintar/actuar en cada momento la que quieras: rejilla2.Pinta_botones(). El código se simplifica mucho, porque te puedes "olvidar" de la parte de la librería, si la tienes bien hecha.
Intenta realizar el constructor y el método de dibujo, y un ejemplo sencillito en el programa principal que cree un objeto y lo pinte, a ver si lo hacemos funcionar y luego lo vamos mejorando.
Saludos.
« Last Edit: December 09, 2013, 06:28:58 pm by noter » Logged

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