Hola
Espero que algún moderador ponga ésto al principio del Post.
Voy a colocar lo que aprendí sobre las librerías gráficas poniendo como ejemplo partes del código de mi proyecto.
No puedo colocarlo todo porque se me esta prohibido dado a que es parte de un proyecto de tesis de Postgrado.
Antes que nada, se debe aclarar que las librerías gráficas de Microchip son gratuitas y se consiguen bajo un paquete
que incluye USB, TCP, entre otros
AQUIYo utilicé el PIC32 starter Kit y la Graphics PICtail Plus Daughter Board with 3.2inch Display Kit que comercializa Microchip y se puede observar
AQUIUna vez instalada la librería y obviamente tener instalado el MPLAB, podemos aventurarnos a probar algunos de los programas de prueba
que se encuentran disponible en la carpeta MICROCHIP SOLUTIONS que es instalada por la librería en la raiz. Yo probé uno:
Antes de poder utilizar la librería, hay que establecer satisfactoriamente comunicación con la controladora de la LCD. Una fuente de preciada
información es el Microchip Graphic Library Help que se encuentra en "C:\Microchip Solutions\Microchip\Help\Graphics Library Help.chm".
Ahí podremos ver la estructura de la librería así como los objetos que se deben configurar. Antes de hablar de la librería, primero debemos
establecer comunicación con la controladora. En la ayuda, nos vamos a HARDWARE PROFILE - GRAPHICS HARDWARE PLATFORM.
La versión de la controladora que yo usé y creo que es la única que se esta vendiendo ahorita es GFX_PICTAIL_V3 y ella además de controlar
la LCD, también incluye una lectora SD y una memoria flash SPI.
En la ayuda, verán un ejemplo de como configurar parcialmente la controladora para los cuatro familias que son compatible con las librerías,
los PIC24F, PIC24H, dsPIC33F y PIC32MX. Queda de parte de ustedes echarle un vistazo a ésta sección, sin embargo, yo ya creé una versión
optimizada de la configuración para mi proyecto. Sin embargo, para quienes vayan a usarla con otro pic que no sea el PIC32 o tenga una versión
diferente de la controladora, el HardwareProfile.h que adjunté sirve para todos los PICs y controladoras.
Ahora vamos a echarle un vistazo a la librería viendo el Microchip Graphic Library Help. La librería se divide en capas como se pueden observar
a continuación:
Application Layer – This is the program that utilizes the Graphics Library.
User Message Interface- This layer should be implemented by user to provide messages for the library.
Graphics Object Layer – This layer renders the widgets controls such as button, slider, window and so on.
Graphics Primitives Layer – This layer implements the primitive drawing functions.
Device Display Driver – This layer is dependent on the display device being used.
Graphics Display Module – This is the display device being used.
Comenzamos con la capa Graphics Display Module y no es mas que la LCD y la controladora a usar. No hay nada mas que ver aquí
y nos vamos a la capa Device Display Driver donde va nuestro archivo de configuración HardwareProfile.H. Esta capa tiene dos
funciones: Una es comunicarse con el hardware y la otra es proveer las instrucciones básicas en la cual se basan todas las operaciones
de las capas superiores como por ejemplo, PutPixel().
Nos vamos a la siguiente capa que es Graphics Primitives Layer y nos vamos a quedar por el momento en ella. Esta capa se basa
obviamente en la anterior y provee funciones para dibujar líneas, círculos, cuadrados, etc etc. Para ver el listado completo de las funciones
que existen en ésta capa, abrir el archivo "Primitives.h" en la carpeta de la librería.
Esta el archivo GraphicsConfig.H el cual nos define las funciones de la LCD que queremos activar. Hay que recalcar que la librería
es bien extensa y no llegué a usar todas sus funciones. Este archivo nos permite activar objetos de la capa de aplicación así
como el acceso a la memoria flash SPI, la SD y el beep de la controladora. La LCD funciona inclusive sin éste archivo pero es bueno tenerlo.
Hay dos formas de arrancar un proyecto. Una es abrir un ejemplo de la librería, borrar todo lo que no vas a usar y usarlo como base
para arrancar tu proyecto o simplemente adjuntar los archivos que vas a requerir. La primera opción se las dejo a ustedes pero les diré
cuales son los archivos que necesitaremos. Una vez hayamos arrancado el MPLAB y creado nuestro proyecto, vamos a organizar que vamos a
agregar.
Primero agregar los header y source files (Los que requieran) a el proyecto desde la carpeta de la librería. Yo agregué todos pero el que se necesita
solamente a éste nivel es el Primitive.H. Sin embargo, cuando vayan a usar objetos o funciones de las aplicaciones superiores, necesitarán
agregarlas. Luego agregamos el archivo de configuración HardwareProfile.H y si queremos, agregamos el header GraphicsConfig.H. El GraphicsConfig.H
será útil a la hora de definir las paletas de colores.
También si queremos usar el beep, la lectora SD y la eeprom en la controladora, deberemos agregar tanto el source como el header Board support package
que consiguen en la librería y son beep.c, cpld.c, eeprom.c, sst25vf016.c y touchscreen.c.
Son muchos archivos que agregar pero es porque la librería en sí es muy amplia y depende de lo que vayan a usar. Para trabajar en la capa primitiva, no
es necesario agregar los archivos Board Support Package. En la capa primitiva, podremos dibujar en la LCD y todo, pero toda la información que se requiere se
consigue en el Microchip Graphic library help, en la sección Graphics Primitive Layers.
Ojo para los que van a usar un demo para usar su proyecto. Los demos tienen solo los archivos que usan ellos y algunos están optimizados por lo que
les puede generar problema.
Luego de haber agregado todos los archivos, vamos a configurar y arrancar la LCD en nuestro Proyecto.C.
Primero incluimos lo siguiente:
#include "GenericTypeDefs.h" //obligatorio
#include "Graphics\Graphics.h" //obligatorio
#include "EEPROM.h" //Solo si queremos usar la eeprom en la controladora
#include "SST25VF016.h" //Solo si vamos a usar la lectora SD
#include "TouchScreen.h" //solo si vamos a usar el touchscreen que se usa en las capas superiores
#include "Beep.h" //solo si se va a usar el beep de la tarjeta
#include "cpld.h" //no se que es pero yo no lo tengo.
Y ahora tenemos que inicializar lo que vayamos a usar
GOL_MSG msg; // GOL message structure to interact with GOL. Es para la capa de aplicación
INTEnableSystemMultiVectoredInt(); //activa el sistema multi vector para la interrupción
SYSTEMConfigPerformance(GetSystemClock()); //La librería se adapta a al velocidad configurada para poder operar adecuadamente.
GOLInit(); // inicializa la librería
SST25Init(); // inicializa GFX3 SST25 flash SPI
// TouchInit(); // inicializa touch screen
InitGraph();
// TickInit(); // inicializa tick counter (for random number generation). No lo van a usar a menos que vayan a usar el touchscreen pero para eso hay que definir el Void que lo que hace es iniciar el Timer 3 para que se active con la interrupción. Cada vez que se interrumpa, ejecuta la función TouchProcessTouch() que es la que lee el touchscreen pero eso es arena de otro costal y no se va a explicar en ésta sección.
Ya tenemos inicializado la LCD y queremos dibujar pero como funciona?
Prácticamente la LCD es una matriz de pixeles pero como es RGB, cada pixel en realidad son 3 pixeles.
Como en cada LCD, la forma de dibujar es ubicándonos en un pixel y activándolo pero como es un pixel RGB, debemos primero darle el color.
Para ello vamos a usar la función SetColor(), el cual acepta números enteros para definir el color. La librería tiene una paleta de colores
pequeña definida en el archivo PeletteColorDefines.H donde podrán ver que hay algunos colores. Por ejemplo, si queremos dibujar en color blanco,
escribimos SetColor(WHITE);, y ya el blanco es seleccionado. Ahora queremos activar un pixel, entonces usamos la instrucción PutPixel(X,Y);,
donde X y Y son las coordenadas donde quieres activar el pixel en color blanco y ya, así de sencillo dibujamos.
Si queremos limpiar podemos seleccionar color negro y barrer los pixeles activados o simplemente limpiar la pantalla con ClearDevice();.
Si queremos escribir, usamos la instrucción OutTextxy(x,y, string); donde X y Y son las instrucciones y string es el texto que queremos usar.
Sin embargo, antes de escribir, se debe seleccionar la fuente y eso se hace una sola vez y se puede hacer al principio del programa con
la instrucción SetFont((void *) &GOLFontDefault);.
Para dibujar líneas, usamos la función LineTo(x,y); el cual nos dibuja una línea desde la posición actual del cursor a la coordenada establecida
y para mover el cursos usamos la función MoveTo(x,y);
Por lo que ven, no es complicado y sé que a veces no es fácil arrancar pero para cerrar la sección de la capa primitiva, voy a colocar un workplace
completo que incluya configuración, todas las librerías e inicializaciones para que sea compatible con todas las funciones de la controladora y de la LCD
de forma que sean ustedes quienes decidan que usar y en base a ese proyecto, colocaré un par de ejemplillos. Eso lo haré la semana que viene.