Ejemplo de uso de las librerías gráficas de Microchip

1. 2011
www.aquihayapuntes.com
Biblioman
[COMENZANDO CON LAS
LIBRERÍAS GRÁFICAS DE
MICROCHIP]
En este tutorial os comento mis primeras impresiones sobre el uso de estas librerías, con
ejemplos de control de dispositivos externos como la regulación de velocidad de un pequeño
motor de C.C a través de la pantalla táctil, espero que os sea de utilidad….

2. Comenzando con las librerías gráficas de Microchip
Introducción
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.
Biblioman www.aquihayapuntes.com Página 2

3. Comenzando con las librerías gráficas de Microchip
El circuito montado será el siguiente:
Conceptos sobre las librerías gráfica s
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 SolutionsGraphics.
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:
Biblioman www.aquihayapuntes.com Página 3

4. Comenzando con las librerías gráficas de Microchip
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).
Biblioman www.aquihayapuntes.com Página 4

5. Comenzando con las librerías gráficas de Microchip
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:
Biblioman www.aquihayapuntes.com Página 5

6. Comenzando con las librerías gráficas de Microchip
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:
Biblioman www.aquihayapuntes.com Página 6

7. Comenzando con las librerías gráficas de Microchip
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
Biblioman www.aquihayapuntes.com Página 7

8. Comenzando con las librerías gráficas de Microchip
asigna 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 el objeto
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 redibuje 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.
 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)
Biblioman www.aquihayapuntes.com Página 8

9. Comenzando con las librerías gráficas de Microchip
/********************************************************************* *
Hardware Configuration for
* Starter Kit
* MultiMedia Development Board
* Display TFT-G240320LTSW-118W-E
********************************************************************/
#include "Alternative
Configurations/HardwareProfile_MULTI_MEDIA_BOARD_DM00123_8PMP_PIC32_STK_SSD192
6_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).
/*********************************************************************
* 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 (an example to create
customized Object).
Biblioman www.aquihayapuntes.com Página 9

10. Comenzando con las librerías gráficas de Microchip
El archivo principal de la aplicación es ControlVelocidadMotor.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)
Biblioman www.aquihayapuntes.com Página 10

11. Comenzando con las librerías gráficas de Microchip
/////////////////////////////////////////////////////////////////////////////
// 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;
Biblioman www.aquihayapuntes.com Página 11

12. Comenzando con las librerías gráficas de Microchip
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;
Biblioman www.aquihayapuntes.com Página 12

13. Comenzando con las librerías gráficas de Microchip
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
Biblioman www.aquihayapuntes.com Página 13

14. Comenzando con las librerías gráficas de Microchip
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. Si el mensaje es válido está función
//llamará a GOLMsgCallback si está definida.
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// 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)
Biblioman www.aquihayapuntes.com Página 14

15. Comenzando con las librerías gráficas de Microchip
{
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 la posición del Meter en 10
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);
}
Biblioman www.aquihayapuntes.com Página 15

16. Comenzando con las librerías gráficas de Microchip
 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
* Dependencies: 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;
Biblioman www.aquihayapuntes.com Página 16

17. Comenzando con las librerías gráficas de Microchip
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){
}
}
Biblioman www.aquihayapuntes.com Página 17

18. Comenzando con las librerías gráficas de Microchip
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. Para cualquier
duda sobre PWM pregunta en este hilo del foro.
Aquí tenéis un vídeo de la aplicación funcionando:
http://www.youtube.com/watch?v=uwdw_fe3rCA
Para saber más sobre el desarrollo de este ejemplo o para hacer cualquier comentario
al respecto lo podéis hacer en el siguiente hilo del foro de aquihayapuntes.com
http://www.aquihayapuntes.com/foro/viewtopic.php?f=20&t=200
Biblioman www.aquihayapuntes.com Página 18

19. Comenzando con las librerías gráficas de Microchip
Fuentes de Información
Multimedia Expansion Board de Microchip
Documentación Librerías gráficas de Microchip
Aplicaciones de Microchip: AN1136, AN1246
CCS Custom Computer Services
Marcas registradas
Las marcas citadas en este artículo así como los programas mostrados en las imágenes
procedentes de capturas de pantallas pertenecen a sus respectivos propietarios, su
utilización en este artículo es con fines educativos y sin ánimo de lucro.
Licencia
Autor de este artículo: Biblioman
Versión: 1.01
Página Web: http:www.aquihayapuntes.com
Email: email.Biblioman@gmail.com
Los comentarios y conclusiones hechos en este artículo son personales y no se
garantiza la veracidad de los mismos por parte del autor, para una información más
amplia y precisa consultar las fuentes citadas.
Este artículo esta bajo una licencia Creative Commons: Reconocimiento-No Comercial-
Compartir bajo la misma licencia.
Biblioman www.aquihayapuntes.com Página 19