Empezando con las librerías gráficas de Microchip
Tutorial de iniciación a las librerías gráficas de Microchip.
MICROCONTROLADORES
Biblioman
8/10/201113 min read
En este pequeño tutorial describiré lo que han sido mis primeras impresiones con las librerías gráficas de Microchip, la idea era controlar algún dispositivo externo que aceptará las órdenes del usuario a través de alguno de los controles gráficos que nos proporciona la librería. Al final ese dispositivo externo se materializo en un pequeño motor de C.C al que a través de dos botones se le puede aumentar o disminuir su velocidad, la aplicación gráfica también incluye un indicador de revoluciones (METER) donde podemos ver el nivel de revoluciones del motor.
Hardware utilizado
La placa principal de desarrollo es la Multimedia Expansion Board de Microchip
Esta placa bajo mi punto de vista viene muy bien equipada en cuanto a periféricos se refiere, entre ellos tenemos: slot para tarjeta microSD, acelerómetro y sensor de temperatura (BMA150), EEPROM externa 24LC08, audio códec (WM8731), conectividad WIFI 802.11, Joystick, etc. La placa no lleva el PIC integrado sino un conector en el que podemos conectar cualquiera de los Starter Kit disponibles, si utilizamos la PIC32 Ethernet Starter Kit además de todo eso tendremos conectividad USB y Ethernet. El único inconveniente que le veo a este tipo de placas es que los pines libres accesibles al PIC para conectar nuestros propios periféricos son pocos (aspecto lógico por otro lado ya que la mayoría de pines están ocupados por los periféricos que integra la propia placa), a pesar de ello está placa dispone de un conector de expansión de 28 pines, no son muchos si además tenemos en cuenta que tres de ellos son de alimentación, pero entre los pines accesibles se encuentran el acceso a las dos USART del pic, por lo que a través de está interfaz podemos conectar cualquier otro dispositivo independientemente del número de pines que necesite para manejar al periférico.
En este ejemplo se va a utilizar la USART Nº 1 del PIC32 para comunicarnos con otro PIC concretamente el PIC16F877, este recibirá las órdenes a través de la interfaz serie y será el encargado de maniobrar el motor de corriente continua. Además el circuito incluye dos componentes más un Buffer (SN74LS126an) utilizado para adaptar por hardware los niveles de tensión de 3,3 V a los que trabaja la placa a los niveles TTL (5V) del resto de los componentes. Y el driver del motor (L293B), necesario ya que el PIC no es capaz de suministrar la corriente necesaria para su funcionamiento.
Nota: algunos pines del pic permiten manejar 5V de salida directamente configurando previamente el pin correspondiente en modo colector abierto. Mirar el datasheet para saber que pines permiten esta configuración.
El circuito montado será el siguiente:
Conceptos sobre las librerías gráficas
Para instalar las librerías solo tenemos que descargar el instalador desde la página web de Microchip e instalarlas ya que son gratuitas, puedes acceder a la página de descarga desde aquí.
Junto con la librerías se instalan una serie de demos que podremos encontrar en la carpeta C:\ Microchip Solutions\Graphics.
La librería solo funciona en PICs de 16 y 32 bits, nuestros queridísimos PIC de 8 bits no tienen recursos suficientes para hacer funcionar la librería.
Como se ve en la figura de abajo la librería presenta una estructura por capas:
En la capa inferior (Device Driver Layer) es donde está implementado el driver o controlador que facilita la comunicación con el módulo GLCD, es por tanto dependiente de la arquitectura del módulo que elijamos, hay disponibles diferentes controladores para el puerto paralelo (PMP) del PIC según el fabricante y la tecnología de LCD Gráfico que tengamos.
La placa Multimedia de Desarrollo de Microchip viene equipada con una QVGA TFT de 320×240 píxeles de resolución y un controlador gráfico, concretamente el Solomon Systech SSD1926 que permite configurar una interfaz de 8 ó 16 bits con el puerto paralelo de PIC (PMP), además se incluye una pantalla táctil resistiva por medio de la cual podemos interactuar con los objetos gráficos que creemos.
El controlador correcto según el módulo LCD gráfico lo elegimos en el archivo de cabecera HardwareProfile.h
La siguiente capa por encima que tenemos es la de funciones gráficas primitivas (Graphics Primitives Functions), esta capa dispone de funciones que permiten realizar la presentación en pantalla de objetos gráficos básicos como líneas, barras, círculos, etc. Esta capa se apoya a su vez en la anterior para poder realizar sus cometidos.
La siguiente capa que tenemos hacía arriba es la capa de objetos gráficos ( Graphics Objects Layer) hace posible que se pueda dibujar en la pantalla los widgets, que son objetos gráficos como botones, ventanas, indicadores, cajas de textos, etc. Esta capa dispone de una interfaz que acepta mensajes de la capa superior (Aplication Layer).
Esta interfaz acepta mensajes de diferentes dispositivos de entrada como teclados, ratones o una pantalla táctil.
Por último tenemos la capa de aplicación, que puede ser cualquier programa que necesite interactuar con las librerías Gráficas. Desde la capa de aplicación podemos acceder a funciones de las capas inferiores.
Nota: a las funciones de una aplicación que pueden ser llamadas para acceder a otras funciones del programa o de alguna librería determinada se las conoce con la abreviatura de API (Application Programming Interface), este término aparece mucho en la documentación que ofrece Microchip sobre estas librerías.
Los objetos gráficos disponibles en las librerías son los siguientes: Button, Slider, Window, Check Box, Radio Button, Edit Box, List Box, Group Box, Horizontal/Vertical Scroll Bars, Progress Bar, Static Text, Picture, Dial, Meter.
La creación y control de los objetos se realiza a través de una estructura de datos conocida en los lenguajes de programación como listas enlazadas.
Cuando se dibuja un objeto gráfico en la pantalla sigue un estilo que determina por ejemplo el color del objeto, el tipo de fuente que utiliza, tamaño etc. Podemos crear nuestro propio estilo o utilizar el que viene por defecto en la librería.
Para añadir una fuente determinada a nuestro programa podemos utilizar la aplicación Graphics Resource Converter proporcionada por Microchip junto con las librerías.
También se pueden añadir imágenes, como fotos o logos:
Esta aplicación lo que hace es convertir la imagen en un formato de archivo que el compilador pueda entender. Admite la opción de elegir entre dos compiladores C32 para los PIC32 y C30 para los PIC de 16 bits. El tipo de formato del archivo depende del destino donde se vaya a guardar, en la flash interna del PIC o en una flash externa, en ambos casos debemos de tener en cuenta el tamaño de la flash ya que según la resolución de la imagen el archivo resultante de la conversión puede ocupar bastantes kB. Si elegimos la flash interna del PIC la aplicación generará dos archivos uno .h (de cabecera) y otro .c donde se creará un Array constante de caracteres con la información de la imagen, luego deberemos añadir los archivos generados por la aplicación a nuestro proyecto. La aplicación también puede convertir la imagen en un archivo binario que se guardará por separado en un archivo externo.
Diagrama de flujo de una aplicación gráfica
El diagrama de flujo de una aplicación gráfica que utilice las librerías de Microchip es el siguiente:
Una descripción breve de lo que hace cada función es la siguiente:
InitGraph() resetea el controlador gráfico, mueve el cursor a la posición (0,0) e inicializa la pantalla en negro.
GolCreateScheme() es llamada para definir el estilo de esquema que se aplicará a los Objetos. Si no creamos ningún estilo personalizado se cogerá el de por defecto.
GolInit() con la llamada a esta función se realizan las acciones de las dos anteriores juntas.
ObjCreate(,,) esta función representa los múltiples objetos que pueden ser creados, hay disponibles funciones específicas para cada clase de objeto que queramos crear. Por ejemplo: BtnCreate() para crear un botón ó MtrCreate() para crear un indicador numérico (METER), las acciones que se realizan al llamar a esta función son: se crea la estructura de datos con las propiedades del objeto, se asigna memoria dinámicamente en el (HEAP) y se incluye el nuevo objeto al final de la lista enlazada, donde se encuentran el resto de los objetos gráficos de nuestra aplicación, por último retorna un puntero al objeto creado.
GOLDraw() esta función es la que se encarga de dibujar los objetos en pantalla. No admite parámetros y su función es chequear los bits de estado de los objetos dentro de la lista enlazada para comprobar si tienen que ser redibujados o no.
Message Struct es una estructura de datos donde se guardan los mensajes enviados por el usuario. Por ejemplo, en una pantalla táctil si se pulsa un botón se almacenará en la estructura las coordenadas (x,y) del botón pulsado y el tipo de evento que ha producido el usuario, por ejemplo si el botón se ha pulsado o por el contrario se ha soltado.
GOLMsg() es la función que se encarga de procesar los mensajes enviados por el usuario. Por ejemplo, cuando se pulse el botón (+) enviar por el puerto serie un valor que indique que lo que se quiere hacer es aumentar la velocidad del motor. Existen más funciones para procesar mensajes como GOLMsgCallback () que además permite personalizar el comportamiento de los objetos en función de su estado y el evento ocurrido. Si esta función está definida es llamada por GOLMsg() cada vez que haya un mensaje valido para el objeto.
En resumen, una vez inicializado el LCD gráfico, creado el objeto y dibujado en la pantalla por medio de GOLDraw() se espera hasta que el usuario desencadene un evento, por ejemplo pulsar un botón, que es procesado entonces por GOLMsg(), para que realice una determinada acción, por ejemplo aumentar la velocidad de un motor o encender un led, después se vuelve a llamar a GOLDraw() para que re-dibuje el objeto (mostrar el botón presionado).
Software
El software de la aplicación se divide en dos partes: el código del PIC32 programado en C32 y que se encarga de realizar la aplicación gráfica y de enviar los comandos por la USART del PIC para aumentar o disminuir la velocidad del motor y el código del receptor (PIC16F877) programado en C con el compilador CCS y que se encarga de recibir los comandos y a través de PWM controlar la velocidad del motor.
1) Código fuente (simplificado) PIC32:
En el archivo HardwareProfile.h definimos las especificaciones Hardware. En el tenemos que des-comentar la siguiente línea. Lo demás lo dejamos comentado. (Solo pongo la línea que hay que poner para no extender el archivo)
/*********************************************************************
* Hardware Configuration for
* Starter Kit
* MultiMedia Development Board
* Display TFT-G240320LTSW-118W-E
********************************************************************/
#include "Alternative Configurations/HardwareProfile_MULTI_MEDIA_BOARD_DM00123_8PMP_
PIC32_STK_SSD1926_TFT_G240320LTSW_118W_E.h"
Esta línea nos incluye el Hardware correcto a nuestro LCD gráfico, en este caso la QVGA TFT que incorpora la Multimedia Expansion Board.
En el archivo GraphicsConfig.h se definen los módulos de la librería gráfica que se van a utilizar, en el ejemplo solo hace falta habilitar los botones y los METER. Lo demás se comenta y no se incluirá en la compilación (de esta manera se ahorran recursos).
print?/******************************************************************
* Overview: To save program memory, unused Widgets or Objects can be
* removed at compile time.
*
******************************************************************/
#define USE_GOL // Enable Graphics Object Layer.
#define USE_BUTTON // Enable Button Object.
//#define USE_WINDOW // Enable Window Object.
//#define USE_CHECKBOX // Enable Checkbox Object.
//#define USE_RADIOBUTTON // Enable Radio Button Object.
//#define USE_EDITBOX // Enable Edit Box Object.
//#define USE_LISTBOX // Enable List Box Object.
//#define USE_SLIDER // Enable Slider or Scroll Bar Object.
//#define USE_PROGRESSBAR // Enable Progress Bar Object.
//#define USE_STATICTEXT // Enable Static Text Object.
//#define USE_PICTURE // Enable Picture Object.
//#define USE_GROUPBOX // Enable Group Box Object.
//#define USE_ROUNDDIAL // Enable Dial Object.
#define USE_METER // Enable Meter Object.
//#define USE_TEXTENTRY // Enable TextEntry Object.
//#define USE_CUSTOM // Enable Custom Control Object
El archivo principal de la aplicación esControlVelocidadMotor.c:
/*****************************************************************************
* CONTROL DE VELOCIDAD DE UN MOTOR DE C.C
* Ejemplo de cómo usar las Librerías gráficas de Microchip
*****************************************************************************
* Nombre del Archivo: ControlVelocidadMotor.c
* Dependencias: ControlVelocidadMotor.h
* Micro: PIC32360512L
* Compilador: MPLAB C32
* Linker: MPLAB LINK32
* Autor: Biblioman
* WEB: www.aquihayapuntes.com
*
*****************************************************************************/
#include "ControlVelocidadMotor.h"
// Configuración de bits y frecuencia de reloj
#pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_4
/////////////////////////////////////////////////////////////////////////////
// IDs de los OBJECTOS
/////////////////////////////////////////////////////////////////////////////
#define ID_BTN1 10
#define ID_BTN2 11
#define ID_METER 20
/////////////////////////////////////////////////////////////////////////////
// COLORES USADOS
/////////////////////////////////////////////////////////////////////////////
#define GRAY20 RGB565CONVERT(51, 51, 51)
#define GRAY40 RGB565CONVERT(102, 102, 102)
#define GRAY80 RGB565CONVERT(204, 204, 204)
#define GRAY90 RGB565CONVERT(229, 229, 229)
#define GRAY95 RGB565CONVERT(242, 242, 242)
#define RED4 RGB565CONVERT(139, 0, 0)
#define FIREBRICK1 RGB565CONVERT(255, 48, 48)
#define DARKGREEN RGB565CONVERT(0, 100, 0)
#define PALEGREEN RGB565CONVERT(152, 251, 152)
#define LIGHTYELLOW RGB565CONVERT(238, 221, 130)
#define GOLD RGB565CONVERT(255, 215, 0)
#define DARKORANGE RGB565CONVERT(255, 140, 0)
/////////////////////////////////////////////////////////////////////////////
// DIMENSIONES DE LOS OBJETOS //
/////////////////////////////////////////////////////////////////////////////
//////////////////DIMENSIONES PARA LOS BOTONES//////////////////////////////////
#define BTN_WIDTH 50
#define BTN_YSTART 160
#define BTN1_XSTART ((GetMaxX()>>1)-10-BTN_WIDTH)
#define BTN2_XSTART ((GetMaxX()>>1)+10)
#define BTN_HEIGHT 50
///// DIMENSIONES PARA EL METER/////////////////
#define MAXMETER1VALUE 70
#define MINMETER1VALUE 10
#define MTR_ORIGIN_X ((GetMaxX() - 260 + 1) / 2)
#define MTR_ORIGIN_Y (((1 + GetMaxY() - 180 + 1) / 2) - 10)
///////////////////////////////////////////////////////////////////////////////
//MACROS PARA INCREMENTAR Y DECREMENTAR EL METER (INDICADOR DE REVOLUCIONES)
///////////////////////////////////////////////////////////////////////////////
#define MtrIncVal(pMtr, deltaValue) MtrSetVal(pMtr, ((pMtr)->value + deltaValue))
#define MtrDecVal(pMtr, deltaValue) MtrSetVal(pMtr, ((pMtr)->value - deltaValue))
///////////////////////////////////////////////////////////////////////////
//MACRO PARA OBTENER EL VALOR DEL METER
///////////////////////////////////////////////////////////////////////////
#define MtrGetVal(pMtr) ((pMtr)->value)
///////////////////PARAMETROS DE CONFIGURACIÓN DE LA USART ////////////////
#define SYS_FREQ (80000000L) //80Mhz
#define PBUS_CLOCK (SYS_FREQ/4) //20Mhz
#define baud (9600) //Se puede cambiar la velocidad en Baudios
//por (9600), (19200), (38400)
//Macro para el cálculo del Baud Rate, utilizando BRGH=0
#define UBRG (((PBUS_CLOCK)/(16*(baud)))-1)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// FUENTES USADAS
/////////////////////////////////////////////////////////////////////////////
extern const FONT_FLASH GOLSmallFont; // Fuente pequeña
extern const FONT_FLASH monofont;
const FONT_FLASH *ptrLargeAsianFont = &GOLFontDefault;
const FONT_FLASH *ptrSmallAsianFont = &GOLSmallFont;
/////////////////////////////////////////////////////////////////////////////
// PLANTILLAS ALTERNATIVAS
/////////////////////////////////////////////////////////////////////////////
GOL_SCHEME *altScheme; // alternativa de esquema
GOL_SCHEME *meterScheme;
METER *pMtr;// Puntero a objeto METER
WORD update = 0; // variable para actualizar el gráfico
int main(void)
{
// Inicialización de la UART1
U2MODEbits.UARTEN = 1; // Enable UART1, 8N1
U2STAbits.URXEN = 1; // Enable UART1 RX pin
U2STAbits.UTXEN = 1; // Enable UART1 TX pin
U2MODEbits.BRGH = 0; // Set High speed mode
U2BRG = UBRG;
////////////////////////////////////////////////////////////////////////////////
GOL_MSG msg; // Declaro Estructura de mensajes. Para interactuar con GOLmsg
INTEnableSystemMultiVectoredInt();
//SYSTEMConfigPerformance(GetSystemClock());
GOLInit(); // inicializa librería gráfica y
// crea un estilo por defecto
TouchInit(); // inicializa el TouchScreen
////////////////////////////////////////////////////////////////////
// CREACIÓN DE LOS ESTILOS
////////////////////////////////////////////////////////////////////
altScheme = GOLCreateScheme(); //Crea esquemas de Estilos alternativas
altScheme->TextColor0 = RED;
altScheme->TextColor1 = BRIGHTBLUE;
meterScheme = GOLCreateScheme();
meterScheme->Color0 = BLACK;
meterScheme->Color1 = WHITE;
meterScheme->TextColor0 = BRIGHTBLUE;
meterScheme->TextColor1 = WHITE;
meterScheme->EmbossDkColor = GRAY20;
meterScheme->EmbossLtColor = GRAY80;
meterScheme->pFont = (void *)ptrSmallAsianFont;
////////////////////////////////////////////////////////////////////////
// CREACIÓN DE LOS OBJETOS GRÁFICOS
////////////////////////////////////////////////////////////////////////
BtnCreate
(
ID_BTN1, //ID del objeto
BTN1_XSTART, //Dimensiones del botón
BTN_YSTART,
BTN1_XSTART+BTN_WIDTH,
BTN_YSTART+BTN_HEIGHT,
10, // Radio de las esquinas del botón.
BTN_DRAW, // Bits de estado. Para Dibujar el Objeto
NULL, // El Botón no usa imagen
"+", // Texto del botón
altScheme // usa el esquema de estilos alternativo
);
BtnCreate
(
ID_BTN2,
BTN2_XSTART,
BTN_YSTART,
BTN2_XSTART+BTN_WIDTH,
BTN_YSTART+BTN_HEIGHT,
10,
BTN_DRAW,
NULL,
"-",
altScheme
);
pMtr = MtrCreate(
ID_METER, // Asignación ID
MTR_ORIGIN_X + 70, // Dimensiones del Objeto
MTR_ORIGIN_Y + 0,
MTR_ORIGIN_X + 198,
MTR_ORIGIN_Y + 130,
MTR_DRAW | MTR_RING | MTR_ACCURACY, // set Draw
MINMETER1VALUE, // set valor inicial
MINMETER1VALUE, // meter mínimo valor
MAXMETER1VALUE, // meter máximo valor
NULL,
(void *) &ptrSmallAsianFont, // set valor de la fuente
"RPM", // Etiqueta de texto
meterScheme // estilo del esquema
);
// set Escala de valores del METER
MtrSetScaleColors(pMtr, BRIGHTGREEN, BRIGHTGREEN, BRIGHTGREEN, BRIGHTGREEN,
BRIGHTYELLOW, BRIGHTRED);
// set valores fuentes para el METER
MtrSetTitleFont(pMtr, (void *)ptrSmallAsianFont);
MtrSetValueFont(pMtr, (void *)ptrSmallAsianFont);
update = 1;
while(1)
{
if(GOLDraw()) //Dibuja el Objeto
{
TouchGetMsg(&msg); // Obtiene mensaje desde el touch screen
GOLMsg(&msg); // Procesar Mensaje
}
}
}
////////////////////////////////////////////////////////////////////////////////
// Función: WORD GOLMsgCallback(WORD objMsg, OBJ_HEADER* pObj, GOL_MSG* pMsg)
// Parametros: objMsg -> Mensaje para el objeto,
// pObj -> Puntero al Objeto,
// pMsg -> puntero a la estructura de Mensajes
// Valor devuelto: si la función retorna un valor distinto de cero el mensaje
// se ha procesado.
// Descripción: es una función definida por el usuario. Es llamada por
// la función GOLMsg()cada vez que se reciba un mensaje válido.
//
////////////////////////////////////////////////////////////////////////////////
WORD GOLMsgCallback(WORD objMsg, OBJ_HEADER pObj, GOL_MSG pMsg)
{
WORD objectID;
objectID = GetObjID(pObj);
METER *pM1doj;
if(objectID == ID_BTN1)
{
// chequea si el botón (+) es presionado
if(objMsg == BTN_MSG_PRESSED)
{
pM1doj=(METER *)GOLFindObject(ID_METER); //Encuentra el puntero Meter.
MtrIncVal(pM1doj,10); //Incrementa en 10 el valor del METER
SetState(pM1doj, MTR_DRAW_UPDATE); //Redibujo solo el Objeto METER
velocidad=MtrGetVal(pM1doj); //Obtengo el valor del Meter
printf("%d",velocidad/10); //Envío por el puerto serie el valor obtenido
}
update = 1;
}
if(objectID == ID_BTN2)
{
// chequea si el botón + es presionado
if(objMsg == BTN_MSG_PRESSED)
{
pM1doj=(METER *)GOLFindObject(ID_METER); //Encuentra el puntero Meter.
MtrDecVal(pM1doj,10); //decrementa en 10 la posición del Meter
SetState(pM1doj, MTR_DRAW_UPDATE); // Redibujo solo el Objeto METER
velocidad=MtrGetVal(pM1doj); //Obtengo el valor del Meter
printf("%d",velocidad/10); //Envío por el puerto serie el valor obtenido
}
update = 1;
}
return (1);
}
2) Código fuente del PIC Receptor:
/*****************************************************************************
* CONTROL DE VELOCIDAD DE UN MOTOR DE C.C
* Código fuente PIC RECEPTOR
*****************************************************************************
* Nombre del Archivo: ControlPWM.c
* Dependencias: Ninguna
* Micro: PIC16F877
* Compilador: CCS
* Autor: Biblioman
* WEB: www.aquihayapuntes.com
*
*****************************************************************************/
#include <16F877.h>
//#device ICD=TRUE
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG
#use delay (clock = 2000000)
#use rs232(uart1, baud=9600)
char dato;
long int duty;
#int_rda
void rd_isr(void)//función de interrupción por recepción de datos USART
{
dato= getc();
switch(dato)
{
case '0':
duty=0;
set_pwm1_duty(duty);
break;
case '1':
duty=7;
set_pwm1_duty(duty);
break;
case '2':
duty=14;
set_pwm1_duty(duty);
break;
case '3':
duty=18;
set_pwm1_duty(duty);
break;
case '4':
duty=20;
set_pwm1_duty(duty);
break;
case '5':
duty=25;
set_pwm1_duty(duty);
break;
case '6':
duty=33;
set_pwm1_duty(duty);
break;
case '7':
duty=40;
set_pwm1_duty(duty);
break;
default:
break;
}
}
void main()
{
enable_interrupts(global);//Habilito interrupción USART
enable_interrupts(int_rda);
setup_timer_2(T2_DIV_BY_1,9,1);
setup_ccp1(CCP_PWM);
duty=0;
set_pwm1_duty(duty);
while(true){
}
}
El código del PIC receptor simplemente varía el ancho del pulso (duty) de la señal generada por PWM, en función del valor recibido por la USART del PIC.
Aquí tenéis un vídeo de la aplicación funcionando: