"Hola Mundo" C18, PIC18F y MPLAB

“Hola Mundo”, MPLAB y C18
Diego Chocobar
d.r.chocobar@gmail.com

26/11/2010

“Hola mundo” y simulación en MPLAB con C18.

Este documento está dirigido para aquellos que deseen empezar con el MPLAB y el
compilador C18, ambos totalmente gratuitos y por mucho, de las herramientas más
completas para trabajar con todas las familias de microcontroladores PIC, ya que este es
creado y actualizado constantemente por Microchip. El compilador C18 utiliza el ANSI C
(ANSI ‘89), por lo que para aquellos con conocimientos incluso de los más básicos sobre el
lenguaje C, programar en MPLAB utilizando este compilador será un proceso de lo más
fácil y ameno.

Esto no pretende ser una guía de uso de estas herramientas, si no que busca ser un
punto de partida para aquellos entusiastas o profesionales inmiscuidos en el mundo de la
electrónica, debido a la falta de explicaciones de principios básicos, es indispensable
contar con conocimientos previos sobre microcontroladores y el manejo de sus registros,
ya que se emplearan explicaciones simples, pero suponiendo el conocimiento previo de
ciertos temas relacionados. Se propondrán pasos muy simples para estar en cuestión de
minutos creando e implementando nuestras aplicaciones. Entonces teniendo un punto de
referencia se espera que con este documento se despierte el interés y se profundice más
en el tema.

Las herramientas usadas para este documento son:

 MPLAB IDE v8.60
 Compilador C18 v3.36 LITE
 Programador PicKit2
 PIC18F2550 y XTAL de 4MHz.

Todos estos “softwares“ se pueden descargar desde www.microchip.com, en su
sección “Development Tools”, y como mencioné previamente, su uso es gratuito, una de
las grandes ventajas de estas herramientas. Sin más preámbulos, una vez descargadas e
instaladas estas herramientas, vamos a empezar con la configuración de las mismas.

“Hola mundo”, MPLAB y C18. Página 2

1. Configuración del MPLAB.

Más que configurar, lo que haremos es percatarnos de que el instalador haya
configurado de manera correcta el MPLAB y el compilador, ya que generalmente, este es
el que se encarga de hacer todo por nosotros. Vamos entonces a cerciorarnos de que el
MPLAB este enlazado con el compilador.

En el IDE (MPLAB), abrimos la herramienta de configuración de compiladores
desde la barra de herramientas Project->Set Language Tool Locations.

Y en la ventana, vamos a tener un listado de las herramientas registradas por
MPLAB. En el momento de la instalación del C18 automáticamente agrega las
variables de entorno para que MPLAB pueda detectar este compilador, por lo que si
seguimos las instrucciones del instalador, en esta ventada veremos listado el
compilador C18: Microchip C18 Toolsuite.


Vamos a comprobar que todas las rutas estén correctas, para ello expandimos
esta opción de Microchip C18 Toolsuite para poder observar las rutas a los ejecutables
correspondientes a cada herramienta del compilador.


Si por cualquier razón no se encuentra cada herramienta, será nuestra tarea
asignarla manualmente. Con las opciones predeterminadas el compilador C18 se
instala en MCC18, y las herramientas se encuentran dentro del directorio BIN, y se
asignan de la siguiente manera:

 MPASM Assembler -> mpasmwin.exe
 MPLAB C18 C Compiler -> mcc18.exe
 MPLIB Librarian -> mplib.exe
 MPLINK Object Linker -> mplink.exe

Una vez comprobado que todo este correcto, hacemos click en “ok”, y estamos
listos para empezar a trabajar en nuestro primer proyecto.


2.-Creando un nuevo proyecto.

Vamos a crear un nuevo proyecto en el cual podremos agregar el o los códigos
fuentes, así como tener la posibilidad de personalizar el área de trabajo, es decir la
posición de las herramientas de las que dispone el MPLAB en caso de usar alguna.
Para esto utilizaremos el asistente de proyecto. Lo encontramos en la barra de
herramientas Project->Project Wizard.

Es muy rápido y sencillo crear el proyecto, después de la bienvenida, debemos
indicar el microprocesador a usar, para este tutorial seleccionaremos el PIC18F2550.


En el siguiente paso vamos a indicar el “Toolsuite” a usar, en nuestro caso
usaremos la suite configurada al principio de este tutorial. Seleccionamos “Microchip
C18 Toolsuite”.

Para el paso tres vamos a ingresar la ruta y nombre del proyecto.


Y por último, el “Project wizard” nos da la opción de agregar archivos de código
fuente en caso de tener alguno ya listo, como este no es el caso, simplemente dejamos
todo como esta, vamos a agregar el archivo que contiene el código manualmente
desde el espacio de trabajo. Nos vamos a la última página que es el sumario del
proyecto y verificamos que todo este correcto.


Hay muchas formas de crear archivos, en este caso vamos a hacerlo desde el
espacio de trabajo recién creado. Creamos un nuevo archivo en File->New y este
mismo archivo lo guardamos en donde guardamos nuestro proyecto recién creado,
con el nombre “main.c”.

Ahora vamos a agregar este archivo al proyecto. Haciendo click con el botón
secundario del mouse sobre la carpeta “Source Files” que nos aparece en el árbol de
archivos del proyecto.

En caso de no tener abierto el archivo de carpetas, lo podemos abrir desde el
menú View->Project.


3.-Includes y los fusibles (Config Words).

Ahora que ya tenemos configurado todo, podemos empezar a escribir nuestro código.
Lo primero que vamos a hacer es establecer los valores de las palabras de configuración
del microcontrolador y agregar las directivas de preprocesador.

Lo primero y mas importante es agregar las librerías adecuadas para el
microcontrolador que estemos trabajando ya que estas contienen todas las estructuras de
los registros del micro y que nos van a permitir accesar a ellos. En nuestro caso la librería
es “p18f2550.h”. También vamos a usar la librería “delays.h”, que nos permite crear
retardos. Estas dos librerías se incluyen con el compilador c18.

#include <p18f2550.h>
#include <delays.h>

Ahora para configurar los fusible, el compilador C18 utiliza la directive:

#pragma config REGISTRO = VALOR

Donde REGISTRO, son los registros de la palabra de configuración y VALOR, las
posibles configuraciones que este puede tomar. A continuación se presenta un pequeño
segmento de los valores de algunos registros de la palabra de configuración.

PLLDIV = 2 Divide by 2 (8 MHz oscillator input)

CPU System Clock Postscaler:
CPUDIV = OSC1_PLL2 [OSC1/OSC2 Src: /1][96 MHz PLL Src: /2]


Para más detalles sobre la configuración y la lista completa para este micro y otros
modelos, consulta el archivo de ayuda incluido con el compilador C18. Si realizaste la
instalación estándar del C18, se instala en MCC18, y dentro de “docs” puedes encontrar el
archivo “hlpPIC18ConfigSet” con todas las opciones disponibles.

Para nuestro código usamos la siguiente configuración de los fusibles.

#pragma config FOSC = XTPLL_XT //Oscilador externo XT (4mhz) con PLL
#pragma config PLLDIV = 1 //Pll sin divisor, es decir, crystal de 4Mhz.
#pragma config CPUDIV = OSC1_PLL2 //PLL/2 es decir, el cpu trabajara a 48Mhz.
#pragma config PWRT = OFF // Power-up timer desactivado.
#pragma config BOR = OFF //Brownout reset desactivado.
#pragma config VREGEN = OFF //Regulador de voltaje usb desactivado
#pragma config WDT = OFF //Watchdog timer desactivado
#pragma config MCLRE = ON //Master Clear activado.
#pragma config LPT1OSC = OFF //Timer 1 condigurada para operacion con
//máxima potencia.
#pragma config PBADEN = OFF //Entradas A/D del puerto B <4:0>
//condiguradas como digitales.
#pragma config STVREN = OFF //Desboradamiento del Stack no causará reset.
#pragma config LVP = OFF //Soporte para una sola fuente de voltaje para
//programacion ICSP desactivada
#pragma config XINST = OFF //Set de instrucciones extendidas desactivado.
#pragma config DEBUG = OFF //Debug desactivado por lo tanto B7 y B6 sirven
//para pines de proposito general.
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF //Proteccion de bloques
//desactivada
#pragma config CPB = OFF //Proteccion del código del boot desactivada
#pragma config CPD = OFF //Protección del código de memoria EEPROM
//desativada.
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF //Proteccion de
//escritura de los bloques
// de memoria desactivada
#pragma config WRTD = OFF //Proteccion de escritura de la memoria EEPROM
//desactivada.

Una vez configurando el hardware básico para la correcta operación del micro, ya
podemos empezar a escribir nuestro código principal.


4.- El código

Para nuestro primer programa, el clásico “hola mundo”, vamos a hacer un ciclo
infinito en el cuál pongamos el puerto B a 11111111, un pequeño delay y poner el puerto
a 00000000.
Lo primero para lograr esto es configurar el puerto B. Es decir, configurarlo para
funcionar como salida digital, recordemos que algunos “pines” del puerto b tiene la
opción de funcionar tanto como salidas/entradas digitales así como anaógicas, por lo que
es muy importante haber ajustado de manera correcta, para el puerto B configuramos las
entradas que tienen opción de ser analógicas para que sean digitales con la configuración
del fusible PBADEN = OFF (#pragma config PBADEN = OFF).Entonces el código será el
siguiente:

void main(void)
{
TRISB = 0x00; //Bits del puerto B configurado como salidas.

while(1) //Ciclo infinito
{
PORTB = 0x00; //Puerto B a ceros.
Delay10KTCYx(255); //Delay
PORTB = 0xFF; //Puerto B a unos.
}
}

Compilamos el código.

Y si todo se siguió al pie de la letra, el compilador nos regresa un mensaje como el
siguiente:


4. Simulando el código.

Podemos probar que nuestro código funcione con el simulador MPLAB SIM, en vez de
descargar el .hex al microcontrolador. Este simulador es muy bueno también para
optimizar el código o detectar errores, ya que podemos simular paso a paso el programa,
observando el comportamiento de los registros internos del micro.
Abrimos el simulador en la barra de herramientas Debugger->Select Tool->MPLAB SI.

Inmediatamente de activar el MPLAB SIM en la barra de herramientas debemos ver
los siguientes íconos, que son con lo que tendremos el control de la simulación del
programa.

El simulador posee muchas herramientas, vamos a usar la herramienta Watch
Window para este ejemplo. La podemos abrir desde el menú View->Watch.


Y nos aparecerá la Watch Window. Esta herramienta, nos permite agregar una lista de
registros de interés, en la cual en la simulación nos mostrara los valores que esos registros
vayan tomando. Tiene la propiedad de indicarnos con un cambio de color (rojo) un
registro que haya sufrido algún cambio.

Vamos a agregar los registros TRISB y PORTB, seleccionando cada registro en la lista y
haciendo click sobre el botón ADD SFR.

Después de agregar ambos registros, la Watch Window debe estar como la siguiente
imagen.


Antes de empezar la simulación, vamos a agregar un “breakpoint” en nuestro código
fuente. Los “breakpoints” nos sirven para detener la simulación en la línea de donde se
encuentre este, esto es muy útil para analizar partes especificas del código, ya que
podemos ejecutar el código a velocidad normal hasta que se encuentre con un
breakpoint, y de ahí correr la simulación paso a paso.
Para agregar un breakpoint basta con hacer doble-click al lado izquierdo de la línea
donde queremos el breakppoint, pero fuera del área de texto, y como resultado
tendremos un punto rojo en nuestro código, y esta línea detendrá la simulación.

Una vez colocado el breakpoint, iniciamos la simulación. Para esto hacer click sobre el
botón “Run”.

Despues de iniciar la simulación podemos observar una flecha verde encima del
breakpoint:


Esto nos indica que la simulación se encuentra detenida en ese punto del código, a
partir de este, vamos a simular línea por línea.

Vamos a hacer click sobre el botón “Step Into” para simular una línea de código, la
que corresponde a TRISB = 0x00;

Nos damos cuenta que después de avanzar un paso en la simulación, en la Watch
Window, la línea que contiene el registro TRISB cambio a color rojo, esto quiere decir que
hubo un cambio en el valor de este registro, en este caso cambió a 0x00. Esto nos
confirma que el programa esta funcionando correctamente.

Avancemos otro paso, para ejecutar la línea que contiene el código PORTB=0x00. En
caso de que el registro haya iniciado con un valor diferente a 0x00, podremos observar
cómo nos avisa del cambio a 0x00, marcando con rojo el nuevo valor. En caso de que el
registro se haya inicializado con 0x00, no marcara con rojo puesto que no hubo cambio.

Vamos un paso delante de nuevo, para llegar la función de retardo. Esta función está
contenida dentro de otro archivo el cual hemos incluido con la directiva #include
<delays.h>. Así pues, al llegar a esta línea, se abrirá una ventana donde esta contenido ese
código para mostrarnos la simulación de este.


Avancemos una cantidad considerables de pasos, y vamos a notar como entra en un
bucle o loop la simulación, que es la rutina que nos crea el retraso. Esta rutina tiene que
alcanzar una cantidad muy grande de pasos para luego salir de ella. Simular esto sería un
pérdida de tiempo, por lo que el simulador cuenta con una función para salir de este tipo
de loops. Para salir y regresar a nuestro código usemos el botón “Step Out”.

Inmediatamente observamos como nos regresa a la siguiente línea de código.


Y podemos seguir avanzando paso a paso para analizar el comportamiento de este
pequeño programa así como los cambios que van ocurriendo en los registros agregados a
la watch window.
A continuación se presenta un código un poco más completo pero igual de simple
para analizar con el simulador.
/*****************************************************************************
* Hola mundo! C18.
* Estructuras
*****************************************************************************
* FileName: main.c
* Dependencies: ninguna
* Processor: PIC18F2550
* Compiler: Microchip C18 C Compiler v3.36
*
* Comentario: Este programa usa las características mas básicas del lenguaje C
* compilado con C18 de Microchip. De igual manera se trabaja con
* lo más básico del hardware del microcontrolador, como son
* los fusibles y los registros TRIS y PORT.
*
* Licencia:
*
* Esta obra está bajo una licencia Attribution-NonCommercial-ShareAlike 3.0 Unported
* de Creative Commons. Para ver una copia de esta licencia,
* visite http://creativecommons.org/licenses/by-nc-sa/3.0/ o envie una carta a
* Creative Commons, 171 Second Street, Suite 300, San Francisco, California
* 94105, USA.
*
*
* Autor Fecha Comentario.
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*Chocobar Diego 26/Nov/2010 Version 1.0
*****************************************************************************/

#include <p18f2550.h>
#include <delays.h>

#pragma config FOSC = XTPLL_XT //Oscilador externo XT (4mhz) con PLL
#pragma config PLLDIV = 1 //Pll sin divisor, es decir, crystal de 4Mhz.
#pragma config CPUDIV = OSC1_PLL2 //PLL/2 es decir, el cpu trabajara a 48Mhz.
#pragma config PWRT = OFF // Power-up timer desactivado.
#pragma config BOR = OFF //Brownout reset desactivado.
#pragma config VREGEN = OFF //Regulador de voltaje usb desactivado
#pragma config WDT = OFF //Watchdog timer desactivado
#pragma config MCLRE = ON //Master Clear activado.
#pragma config LPT1OSC = OFF //Timer 1 condigurada para operacion con máxima
//potencia.
#pragma config PBADEN = OFF //Entradas A/D del puerto B <4:0> condiguradas como
//digitales.
#pragma config STVREN = OFF //Desboradamiento del Stack no causará reset.
#pragma config LVP = OFF //Soporte para una sola fuente de voltaje para
//programacion ICSP desactivada
#pragma config XINST = OFF //Set de instrucciones extendidas desactivado.
#pragma config DEBUG = OFF //Debug desactivado por lo tanto B7 y B6 sirven para
//pines de proposito general.
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF //Proteccion de bloques
//desactivada


#pragma config CPB = OFF //Proteccion del código del boot desactivada
#pragma config CPD = OFF //Protección del código de memoria EEPROM
//desativada.
#pragma config WRT0 = OFF, WRT1 = OFF, WRT2 = OFF, WRT3 = OFF //Proteccion de
//escritura de los
//bloques de memoria
//desactivada
#pragma config WRTD = OFF //Proteccion de escritura de la memoria EEPROM desactivada.

/****************************************************
P R O T O T I P O S
*****************************************************/

int CfgPorts(void);

/****************************************************
M A I N
*****************************************************/

void main(void)
{
int k;

CfgPorts(); //Llamada a la function de configuración.

while(1) //Ciclo infinito
{
PORTB = 0x01; //Puerto B a 0x01

for(k=0;k<7;k++) //Ciclo for para multiplicación (corrimiento)
{
PORTB*=2; //PORTB= PORTB * 2;
}
}
}

/****************************************************
F U N C I O N E S
*****************************************************/

int CfgPorts(void)
{
ADCON1 = 0x0F; //Todas los pines disponibles para anaógico/digital
//condigurados como digitales.
TRISA = 0xFF; //Bits del puerto A configurado como entradas.
TRISB = 0x00; //Bits del puerto B condigurado como salidas.
}


Esta obra está bajo una licencia Attribution-NonCommercial-ShareAlike 3.0 Unported de
Creative Commons. Para ver una copia de esta licencia, visite
http://creativecommons.org/licenses/by-nc-sa/3.0/ o envie una carta a Creative Commons, 171
Second Street, Suite 300, San Francisco, California 94105, USA.


"Hola Mundo" C18, PIC18F y MPLAB

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (13)

Similar a "Hola Mundo" C18, PIC18F y MPLAB

Similar a "Hola Mundo" C18, PIC18F y MPLAB (20)

Último

Último (16)

"Hola Mundo" C18, PIC18F y MPLAB