2/4/2020
Acerca de mi Blog Tutoriales
PROMOCIONES EN DX
ENTRADAS POPULARES
Tutorial MPLABX XC8 parte
3: Crear librerías–librería
UART para PIC16F628A
Hola amigos, en este tutorial
veremos cómo crear librerías
para el manejo de módulos
externos, específicamente
para la comunicación
serial...
Tutorial FPGA en VHDL:
Parte 2, comparador de 2
bits y simulación
En esta oportunidad
realizaremos el diseño en
VHDL para un comparador
de 2 bits basado en el
tutorial anterior, con la
peculiaridad que uti...
Tutorial MPLABX XC8 parte
1: Crear un proyecto y "hola
mundo"
Saludos: Tomando un
descanso de la programación
de FPGAs, he decidido hacer
un tutorial de
microcontroladores. En esta
serie abarcaré ...
Placa de desarrollo de
dspic30F4011 y
dspic30F4012
Hola a todos, en esta ocasión
quiero compartir con
ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html
Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
Proyectos Renuncia de Responsabilidad
MIÉRCOLES, 9 DE JULIO DE 2014
PUBLICID
Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
TRANSLA
Saludos: Sele
Tomando un descanso de la programación de FPGAs, he decidido hacer un tutorial de microcontroladores. BUSCAR
En esta serie abarcaré la programación de microcontroladores PIC serie 16 (16F628A y 16F877A), con el
objetivo de ganar un poco de experiencia y utilizar estos conocimientos para la programación de la serie
dsPIC.
SECCION
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 básicos se obviarán.
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 página de descargas en el archivo de microchip, por lo que tenemos
que actualizarnos nosotros también. Esto en verdad es una pena, pues he encontrado muy difícil
acostumbrarme al nuevo entorno de desarrollo MplabX, aún encuentro confuso la configuración requerida
para programar en ensamblador y cuestiones similares, pero, para esto es la guía, 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 opción. Cuando Microchip lanzó las primeras versiones de MplabX, ésta utilizaba los
compiladores C18 y C30 para la programación en C. La versión más reciente (2.15) trabaja con XC8, XC16 y
XC32, así que no nos queda más que aprender a utilizar las nuevas herramientas.
Por eso también me tocó aprender el XC8, es una pena que se cambie tan rápido (en menos de 2 años) las
herramientas de desarrollo, pero ¿qué más podemos hacer?
¿Por qué la familia PIC16?
Pues es la más fácil de aprender, y además estos microcontroladores son los que se pueden conseguir en
Cuenca-Ecuador. Si quieres que haga un tutorial sobre otro microcontrolador, pues sus regalos serán
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 más, requeriremos realizar la programación en ensamblador, y
no en C como se tiene planificado. Pero no te desanimes, se toparán temas complejos como la utilización de
1/9
2/4/2020
ustedes una placa para
desarrollo de proyectos con
DSPIC30F4011 y
DSPIC30F4012 con el ob...
DATOS PERSONALES
Miguel Davila
Ver todo mi perfil
ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html
Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
LCDs gráficos 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 módulo
GPS, GSM, USB, GLCD o similar, sin saber a fondo cómo envía 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 programación 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 continuación nos pedirá el tipo de conexión para el debugger, para el cual seleccionamos "None" y damos
click en siguiente. Después no pedirá la herramienta de depuración a utilizar, para la cual seleccionamos
"Simulador" (esto puede ser diferente si tienes un programador que pueda realizar depuración).
2/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"

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), librerías y demás. Esta es una de las características de
MPLABX que en realidad me gusta, pues nos permite ordenar nuestro proyecto de una manera bastante
sencilla.

Tercer paso: Programación de "hola mundo"

Para todos los que nos gusta la electrónica, sabemos que el equivalente al "hola mundo" en programación, es
encender un LED, específicamente 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 configuración del microcontrolador

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 3/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"

Para esto hacemos click derecho en Header Files>New>C Header File.

Luego creamos el archivo de encabezado en la dirección del proyecto

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

En esta herramienta seleccionaremos los siguientes bits de configuración:

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

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 4/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"

Hacemos click en "Generate Source Code to Output", copiamos y pegamos el código generado en al archivo
hmheader.h:

2) Crear un archivo fuente con el código del programa

Una vez creado el encabezado, podemos crear el código fuente de la aplicación, para lo cual hacemos click
derecho en Source Files>New>C Main File

Le damos un nombre al archivo e ingresamos el código fuente del mismo. Dicho código es el siguiente:

1 /*
2 * File: hmheader.h
3 * Author: MIGUEL
4 *
5 * Created on 9 de julio de 2014, 10:07 p.m.
6 */
7
8
9 // PIC16F628A Configuration Bit Settings
10
11 // 'C' source line config statements
12
13 #include <xc.h>
14
15 // #pragma config statements should precede project file includes.
16 // Use project enums instead of #define for ON and OFF.
17
18 // CONFIG
19 #pragma config FOSC = INTOSCIO // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKO
20 #pragma config WDTE = OFF // Watchdog Timer Enable bit (WDT disabled)
21 #pragma config PWRTE = OFF // Power-up Timer Enable bit (PWRT disabled)
22 #pragma config MCLRE = OFF // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital
23 #pragma config BOREN = ON // Brown-out Detect Enable bit (BOD enabled)
24 #pragma config LVP = OFF // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, H
25 #pragma config CPD = OFF // Data EE Memory Code Protection bit (Data memory code protection off)
26 #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)
27
28

configuracion hosted with ❤ by GitHub view raw

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 5/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
1 /*
2 * File: hmmain.c
3 * Author: MIGUEL
4 *
5 * Created on 9 de julio de 2014, 10:28 p.m.
6 */
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include "hmheader.h"
11
12 #define _XTAL_FREQ 4000000 // se define la frecuencia del cristal para los retardos
13
14 /*==============================================================================
15 Inicializar puertos, esta función es llamada luego en el main().
16 ==============================================================================*/
17
18 void initPorts(void)
19 {
20 TRISB = 0b00000000; // Todo el puerto B es salida
21 PORTB = 0; // Se apaga todo el puerto B
22 }
23
24 /*==============================================================================
25 Bucle principal
26 ==============================================================================*/
27
28 int main(void)
29 {
30 // Inicializar puertos y periféricos
31 initPorts();
32
33 // Repetir indefinidamente
34 while(1)
35 {
36 // prender puerto B
37 PORTB = 0b11111111;
38 _delay(1000000); //retardo de 1 millón de pulsos de reloj
39
40 // apagar puerto b
41 PORTB = 0b00000000;
42 _delay(1000000);
43 }
44 }
45

main hosted with ❤ by GitHub view raw

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

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 inicialización: 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 código para
encender y apagar los bits del puerto B (PORTB=0b11111111). Se utiliza un retardo
(_delay(1000000)) de un millón 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 millón 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):

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 6/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
Tiempo de retardo=[1/(4M/4)] x 1M=1 segundo

Por lo que el tiempo del cristal dicta la duración de los retardos.

Cuarto paso: Simulación en MPLABX

Para entender el por qué de mi afirmación que la programación en C es para proyectos simples que no
demandan una exactitud elevada en retardos, se realizará la simulación del programa y se observará la
diferencia de tiempos. Para esto compilamos el proyecto, y si no hay errores, hacemos click en la opción de
depuración.

Creamos 2 Breakpoints para detener la simulación. Si no hacemos esto, la simulación se realizará muy
rápidamente y no podremos ver los cambios de registros, variables o contar el tiempo entre instrucciones.

Iniciamos la simulación, 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 cronómetro.

Volvemos a iniciar la simulación, y veremos que el lo que debía 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 función del número de ciclos que toma cada directiva del código, y el tiempo de ciclo
del reloj, pero es algo que quería recalcar pues muchos estudiantes o aficionados inician su aprendizaje en
MPLABX y desconocen que si en el código 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: Simulación en Proteus

Aunque Proteus no es software libre, no he encontrado otra opción similar de código abierto, por lo que las

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 7/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"
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.

Continuar a la Parte 2...

Es todo por hoy, cualquier pregunta al respecto estaré gustoso de ayudarles. Hasta una próxima entrega,
adiós.

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 8/9
2/4/2020 Ipsotron: Tutorial MPLABX XC8 parte 1: Crear un proyecto y "hola mundo"

Publicadas por Miguel Davila a la/s 23:42

Etiquetas: C, Hardware, Microcontroladores, MPLABX, Programación, software, XC8

No hay comentarios:

Publicar un comentario

Introduce tu comentario...

Comentar como: maryuriabreu8 Cerrar sesión

Publicar Vista previa Avisarme

Entrada más reciente Página principal Entrada antigua

Suscribirse a: Enviar comentarios (Atom)

Miguel Dávila S. Algunos derechos reservados. Tema Picture Window. Con la tecnología de Blogger.

ipsotron.blogspot.com/2014/07/tutorial-mplabx-xc8-parte-1-crear-un.html 9/9