Tutorial MPLABX XC8: Crear un proyecto y "hola mundo"

Saludos:

Tomando un descanso de la programacin de FPGAs, he decidido hacer un tutorial de

microcontroladores. En esta serie abarcar la programacin de microcontroladores PIC serie
16 (16F628A y 16F877A), con el objetivo de ganar un poco de experiencia y utilizar estos
conocimientos
para
la
programacin
de
la
serie
dsPIC.
Este tutorial est pensado para los que ya saben qu es un microcontrolador, y han trabajado
antes en ensamblador para PIC, por lo que algunos criterios bsicos se obviarn.

Pero primero:

Por qu trabajar en MPLABX?

Decid programar en MPLABX por las siguientes razones:

1) El Mplab IDE antiguo, en el cual muchos de nosotros aprendimos a programar en la

universidad, fue actualizado, as que solo se consigue en la pgina de descargas en el archivo
de microchip, por lo que tenemos que actualizarnos nosotros tambin. Esto en verdad es una
pena, pues he encontrado muy difcil acostumbrarme al nuevo entorno de desarrollo MplabX,
an encuentro confuso la configuracin requerida para programar en ensamblador y
cuestiones similares, pero, para esto es la gua, para en el transcurso de la misma
familiarizarnos con esta nueva herramienta.
2) Siempre es recomendable programar en los entornos de desarrollo de los fabricantes. Esto
pues aunque existan plataformas como Pinguino, Chipkit o Arduino, si tu objetivo es aprender
a programar un microcontrolador, es mejor hacerlo en el lenguaje y/o la plataforma que el
fabricante nos recomienda.

Por qu XC8?

Pues bien, no hay otra opcin. Cuando Microchip lanz las primeras versiones de MplabX,
sta utilizaba los compiladores C18 y C30 para la programacin en C. La versin ms
reciente (2.15) trabaja con XC8, XC16 y XC32, as que no nos queda ms que aprender a
utilizar las nuevas herramientas.

Por eso tambin me toc aprender el XC8, es una pena que se cambie tan rpido (en menos de
2 aos) las herramientas de desarrollo, pero qu ms podemos hacer?

Por qu la familia PIC16?

Pues es la ms fcil de aprender, y adems estos microcontroladores son los que se pueden
conseguir en Cuenca-Ecuador. Si quieres que haga un tutorial sobre otro microcontrolador,
pues sus regalos sern bienvenidos ;-).

Objetivo de estos tutoriales:

Utilizar las herramientas de Microchip para proyectos de baja complejidad, es decir, a los
proyectos en los cuales no se requiera exactitud en tiempos, altas velocidades, etc. Esto pues
si queremos que un retardo dure exactamente un segundo, ni un microsegundo ms,
requeriremos realizar la programacin en ensamblador, y no en C como se tiene planificado.
Pero no te desanimes, se toparn temas complejos como la utilizacin de LCDs grficos a
colores, memorias SD, etc. Siempre teniendo en cuenta el funcionamiento real del
microcontrolador. A qu quiero llegar con esto?, pues bien, si tu objetivo es meramente
utilizar un mdulo GPS, GSM, USB, GLCD o similar, sin saber a fondo cmo enva los datos
el micro, pues este tutorial no es para ti. Para eso se utiliza Arduino o Pinguino ( los cuales
abarcaremos en otra oportunidad).

Primer paso: descargar e instalar MPLabX y XC8

Para programar un microcontrolador de Microchip debemos descargar el entorno de

desarrollo MPLabX, pero el mismo no nos permite realizar la programacin en C de manera
inmediata, para esto tenemos que descargar el compilador XC8.

Primero instalamos MPLabX, y luego el compilador XC8. Una vez hecho iniciamos el
programa y veremos la siguiente pantalla:

Segundo paso: Crear un nuevo proyecto

Hacemos click en File>New Project, y seleccionamos Standalone Project.

En la siguiente pantalla seleccionamos el microcontrolador que queremos utilizar, en nuestro

caso ser el PIC16F628A

A continuacin nos pedir el tipo de conexin para el debugger, para el cual seleccionamos
"None" y damos click en siguiente. Despus no pedir la herramienta de depuracin a
utilizar, para la cual seleccionamos "Simulador" (esto puede ser diferente si tienes un
programador que pueda realizar depuracin).

Luego seleccionamos el compilador, en nuestro caso ser el XC8 V1.32:

Y por ltimo le damos un nombre al proyecto (holamundo):

Hacemos click en Finalizar, y se crear el directorio base para nuestro proyecto, el cual se
muestra en la figura.

Como podemos observar se crean subcarpetas en el proyecto destinadas a contener los

archivos de cabecera (headers .h), los archivos de fuente (source .c), libreras y dems. Esta
es una de las caractersticas de MPLABX que en realidad me gusta, pues nos permite ordenar
nuestro proyecto de una manera bastante sencilla.
Tercer paso: Programacin de "hola mundo"
Para todos los que nos gusta la electrnica, sabemos que el equivalente al "hola mundo" en
programacin, es encender un LED, especficamente hacerlo encender y apagar en un periodo
de
tiempo.
Para
esto
debemos
seguir
los
siguientes
pasos:
1) Crear un archivo de encabezado con los bits de configuracin del microcontrolador
Para esto hacemos click derecho en Header Files>New>C Header File.

Luego creamos el archivo de encabezado en la direccin del proyecto

Borramos el contenido por defecto que crea MPLABX en el archivo de encabezado para
cargar nuestro propio cdigo. En este archivo ingresaremos los bits de configuracin del
microcontrolador, es decir, las directivas para programacin en alto o bajo voltaje, la
configuracin del oscilador, etc. Para esto existe una herramienta que nos permite generar el
cdigo requerido, la cual se encuentra en Window>PIC Memory Views>Configuration Bits

En esta herramienta seleccionaremos los siguientes bits de configuracin:

Oscilador: Interno sin clockout

Watchdog Timer: desactivado

Power-Up Timer: desactivado

MCLRE: desactivado

Brown-out detect: activado

LVP: desactivado

Data protection: desactivado

Code protection: desactivado

Hacemos click en "Generate Source Code to Output", copiamos y pegamos el cdigo

generado en al archivo hmheader.h:

2)

Crear

un

archivo

fuente

con

el

cdigo

del

programa

Una vez creado el encabezado, podemos crear el cdigo fuente de la aplicacin, para lo cual
hacemos click derecho en Source Files>New>C Main File

Le damos un nombre al archivo e ingresamos el cdigo fuente del mismo. Dicho cdigo es el
siguiente:
/*
* File: hmheader.h
* Author: JosDarw
*
* Created on 21 de enero de 2017, 11:07 p.m.
*/
// PIC16F628A Configuration Bit Settings
// 'C' source line config statements
#include <xc.h>
// #pragma config statements should precede project file includes.
// Use project enums instead of #define for ON and OFF.
// CONFIG
#pragma config FOSC = INTOSCIO // Oscillator Selection bits (INTOSC
oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on
RA7/OSC1/CLKIN)
#pragma config WDTE = OFF
disabled)

// Watchdog Timer Enable bit (WDT

#pragma config PWRTE = OFF

disabled)

// Power-up Timer Enable bit (PWRT

#pragma config MCLRE = OFF

// RA5/MCLR/VPP Pin Function Select bit
(RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
#pragma config BOREN = ON
enabled)

// Brown-out Detect Enable bit (BOD

#pragma config LVP = OFF

// Low-Voltage Programming Enable bit
(RB4/PGM pin has digital I/O function, HV on MCLR must be used for
programming)
#pragma config CPD = OFF
// Data EE Memory Code Protection bit
(Data memory code protection off)
#pragma config CP = OFF
(Code protection off)

// Flash Program Memory Code Protection bit

___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___
/*
* File: hmmain.c
* Author: JosDarw
*
* Created on 21 de enero de 2017, 11:28 p.m.
*/
#include <stdio.h>
#include <stdlib.h>
#include "hmheader.h"
#define
_XTAL_FREQ
cristal para los retardos

4000000

// se define la frecuencia del

/
*============================================
==================================
Inicializar puertos, esta funcin es llamada luego en el main().
=============================================
=================================*/
void initPorts(void)
{
TRISB = 0b00000000;
PORTB = 0;

// Todo el puerto B es salida

// Se apaga todo el puerto B

}
/
*============================================
==================================
Bucle principal

=============================================
=================================*/
int main(void)
{
// Inicializar puertos y perifricos
initPorts();
// Repetir indefinidamente
while(1)
{
// prender puerto B
PORTB = 0b11111111;
_delay(1000000); //retardo de 1 milln de pulsos de reloj
// apagar puerto b
PORTB = 0b00000000;
_delay(1000000);
}
}
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________
___

Se incluye el encabezado: #include "hmheader.h" para cargar los bits de configuracin

Se define la velocidad del cristal 4000000Hz. Aunque no utilizamos un cristal

externo, se debe declarar la velocidad del cristar interno del microcontrolador para que
las rutinas de retardo funcionen adecuadamente.

Se crea una subrutina de inicializacin: void initPorts (void), en la cual definimos al

puerto B como salida (TRISB=0b00000000) y lo inicializamos con todos los bits
apagados (PORTB=0).

En el bucle principal se llama a la subrutina para inicializar puertos, y se coloca el

cdigo para encender y apagar los bits del puerto B (PORTB=0b11111111). Se utiliza
un retardo (_delay(1000000)) de un milln de pulsos de reloj, lo cual nos equivale a 1

segundo de retardo con el oscilador interno de 4MHz. Esto se debe tener en cuenta,
pues si utilizamos un oscilador de 20 MHZ, un retardo de 1 milln de pulsos de reloj
nos equivale a 200ms.
El tiempo de retardo se calcula de la siguiente manera:

Tiempo de retardo=[1/(Frecuencia del cristal/4)] x Valor de pulsos en el retardo

Para el ejemplo (Cristal interno de 4MHz):

Tiempo de retardo=[1/(4M/4)] x 1M=1 segundo

Por lo que el tiempo del cristal dicta la duracin de los retardos.

Cuarto paso: Simulacin en MPLABX
Para entender el por qu de mi afirmacin que la programacin en C es para proyectos
simples que no demandan una exactitud elevada en retardos, se realizar la simulacin del
programa y se observar la diferencia de tiempos. Para esto compilamos el proyecto, y si no
hay errores, hacemos click en la opcin de depuracin.

Creamos 2 Breakpoints para detener la simulacin. Si no hacemos esto, la simulacin se

realizar muy rpidamente y no podremos ver los cambios de registros, variables o contar el
tiempo entre instrucciones.

Iniciamos la simulacin, con lo que la misma se detendr en el primer Breakpoint. Hacemos

click en "StopWatch" en la parte inferior de la pantalla, y reiniciamos el cronmetro.

Volvemos a iniciar la simulacin, y veremos que el lo que deba haber durado 2 segundos, en
realidad dur 2.000033 segundos.

Pues bien, este resultado no es una sorpresa para los que ya han programado en ensamblador,
pues los retardos se calculan en funcin del nmero de ciclos que toma cada directiva del
cdigo, y el tiempo de ciclo del reloj, pero es algo que quera recalcar pues muchos
estudiantes o aficionados inician su aprendizaje en MPLABX y desconocen que si en el
cdigo le digo al micro que se demore 1 segundo en una actividad, esto puede no ser siempre

cierto, por lo tanto, si queremos tiempos exactos debemos utilizar ensamblador y no C.

Quinto Paso: Simulacin en Proteus
Aunque Proteus no es software libre, no he encontrado otra opcin similar de cdigo abierto,
por lo que las simulaciones las har en este software. Proteus es un software de pago, por lo
que conseguirlo corre por tu cuenta.
Una vez iniciado el programa agregamos el microcontrolador utilizado.

Dibujamos el circuito para encender y apagar 8 leds, como se muestra en la figura

Por ltimo, haciendo doble click sobre el micro, cambiamos la velocidad del oscilador, y
cargamos el archivo .hex de la carpeta "dist>default>production" del proyecto.

Con esto podremos simular adecuadamente el programa, y cargarlo al microcontrolador con

cualquier programador.