empezando con las librerías gráficas de microchip

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

Comenzando con las librerías gráficas de Microchip

Biblioman www.aquihayapuntes.com Página 2

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.

http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2615&dDocName=en548037

http://www.alldatasheet.com/datasheet-pdf/pdf/27377/TI/SN74LS126AN.html

http://www.datasheetcatalog.org/datasheet/SGSThomsonMicroelectronics/mXurruu.pdf



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 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:

http://es.wikipedia.org/wiki/Lista_%28inform%C3%A1tica%29



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



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)



/********************************************************************* *

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



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



{

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);

}



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;


break;

case '2':

duty=14;


break;



case '3':

duty=18;


break;

case '4':

duty=20;


break;

case '5':

duty=25;


break;

case '6':

duty=33;


break;

case '7':

duty=40;


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;


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







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 protected]

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.



http://ww1.microchip.com/downloads/en/AppNotes/01136a.pdf

http://ww1.microchip.com/downloads/en/AppNotes/01246b.pdf

http://www.ccsinfo.com/

http://www.aquihayapuntes.com/

mailto:[email protected]

empezando con las librerías gráficas de microchip

Technology