PIC32 + librerías gráficas

[Suky]

¿El paso a booleano no es automático, Suky?

No. Por lo menos en C30 y C18. Y CCS me parece que tampoco, como no se usa esta forma 


Saludos!

[Nocturno]

En CCS sí funciona sin convertirlo, pero no se puede asignar el pin directamente con esa sintaxis, ya que hay que definirlo previamente como #bit.

Pues gracias por la aclaración.

[elavismo]

Gracias amigos. De hecho funciona como dijo Suky.

Puedo invertirlo en el caso de que quiera mandar el bit de un puerto a la variable?

[Suky]

Ahí puedes hacerlo de varias formas, por ejemplo para colocar el bit en la posición bit5 de la variable:

Código: C

1. Variable=PORTBbits.RB15<<5;
2. Variable=PORTBbits.RB15*0x40;

Otra puede ser crear un "estilo" de estructura para crear la variable y acceder a cada bit:

Código: C

1. typedef union{
2.      unsigned char Val;
3.      struct{
4.           unsigned bit0:1;
5.           unsigned bit1:1;
6.           unsigned bit2:1;
7.           unsigned bit3:1;
8.           unsigned bit4:1;
9.           unsigned bit5:1;
10.           unsigned bit6:1;
11.           unsigned bit7:1;
12.      };
13. }UINT8_VAL;
14.  
15.  
16. UINT8_VAL Variable;

Para leer/escribir el byte completo haces Variable.Val=0x15 por ejemplo, y para acceder a los bits:

Código: C

1. Variable.bit5=PORTBbits.RB15;

Saludos!

[elavismo]

Vaya Suky.

Muchas gracias. Ya ayer modifiqué mis líneas y los hice funcionar. Tengo un problemita tratando de mostrar en la lcd el texto. Hay una instrucción en la librería que es
OutTextXY(X, Y, string); y quería colocar ahí el valor entero que estoy trayéndome de el bus que hice. Es decir, tengo el valor en la variable Dato y mostrar el número entero como un string. Era para visualizar el valor que el ADC me estaba dando. Si escribo el string directo, OutTextXY(275, 128, "luis"); si sale pero quiero poner es el valor en Dato. Tengo que hacerlo con printf, no?

[Suky]

Puedes crear un buffer para guardar el string temporalmente, utilizar sprintf para general el string a partir de la variable, y al lcd cargarle el buffer.


Saludos!

[elavismo]

No sé pq no me llegó el email de notificación de respuesta.


Tengo mi variable unsigned long Datax y tengo mi buffer char buf[6] y agregué el include <stdlib.h> para usar el itoa
itoa ( Datax, buf, 10); para luego hacer el printf pero me da error al compilarlo.

Undefined reference to ´itoa´

Al revisar el archivo stdlib.h, veo que el itoa no está. Esta es atoi que creo es de cadena a entero pero no el itoa que es de entero a string.

Entonces según leo en un foro de microchip, al parecer el itoa no existe en C de pic pero señalan usar sprintf en vez de itoa. No sé como usar el printf para eso
porque intenté colocando por ejemplo printf("Data = %d\n", Datax); pero el pic se queda pegado. No avanza a donde visualizo otras cosas en la LCD por lo que sé que se está quedando pegado en printf
 

[elavismo]

Ya lo hice!

usé el sprintf(buf, "%d\n", Datax); y ya muestro el valor en la LCD mostrando a buf

Gracias

[elavismo]

Hola Suky

Una preguntilla a ver si sabes que pasa. Se supone que el PIC32 a 80mhz ejecuta una instrucción en un ciclo y da 12,5ns, no?
porque una simple operación como limpiar un bit que sería un BCF y subirlo que sería un BSF en ensamblador, se toma 100ns.
Lo medió con el osciloscopio y se toma 100ns exactos.


   mPORTGClearBits(BIT_2);   
         
   PORTSetBits(IOPORT_G, BIT_2);

[Suky]

Los PIC32 trabajan con cache, lo has configurado correctamente? Después puede que C32 genere código asm que no se entiende (pasa en C30), eso lo puedes ver yendo a view/list disasembly o algo así  Eso depende mucho del nivel de optimización.


Saludos!

[elavismo]

Si estuve tratando de ver que código assembly puso pero no lo vi.
Esta es mi configuración para 80 mhz

#pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_1

[Suky]

La siguiente sentencia la tienes implementada?

Código: [Seleccionar]

SYSTEMConfigPerformance(80000000L);

[elavismo]

No la tengo 

[elavismo]

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 AQUI

Yo utilicé el PIC32 starter Kit y la Graphics PICtail Plus Daughter Board with 3.2inch Display Kit que comercializa Microchip y se puede observar
AQUI



Una 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.

[migsantiago]

Oye, gracias por los pasos para usar esta librería.

Sobre el mensaje en el primer post, creo que no hace falta. Los interesados no se deberán cansar de leer todo. Y si se cansan... entonces no están interesados.