c:\documents and settings\earias\escritorio\pic 32\iniciacion a la programacion de los pic32

$: C:\Documents And Settings\Earias\Escritorio\Pic 32\Iniciacion A La Programacion De Los Pic32$
2010

Biblioman

www.aquihayapuntes.com

13/02/2010

Iniciación a la programación de los PIC32

Iniciación a la programación de los PIC32 2

www.aquihayapuntes.com | Biblioman 2

Iniciación a la programación de los PIC32

Con este artículo empezamos con una serie de ejemplos

dedicada a la programación de los PICs de la gama alta de

Microchip, los de 32 bits. Primeramente voy a describir las

diferentes herramientas que necesitaremos para empezar a experimentar con estos

dispositivos, que empezaron su andadura a finales del 2007 y que a pesar de que ya hay

abundante documentación y ejemplos en ingles, la información en Español es escasa por

no decir nula.

Hardware necesario

Microchip ha desarrollado dos tipos de kit básicos de aprendizaje para el desarrollo con

estos dispositivos:

La placa de desarrollo Explorer 16:



Como se ve en la figura de arriba, además de la placa se necesitan los módulos que

incluyen los Microcontroladores que pueden ser de 16 ó 32 bits. Y tendremos que tener

también el programador/depurador: ICD2, ICD3 ó el MPLAB REAL ICE.

La plataforma Starter Kit

A medida que microchip a ido mejorando las funcionalidades de estos PIC ha ido

sacando nuevos kit para esta placa de desarrollo, actualmente disponemos de los

siguientes: DM320001, DM320003, DM320004. Esta última incluye un PIC de la

familia PIC32MX7 con 128 kbytes de memoria RAM, conectividad Ethernet de 10/100

Mbit/s, dos controladores CAN 2.0b, USB Host, Device y OTG, 6 puertos UART, 5

puertos I2C , 4 SPI y 16 canales de DMA.

Estos tres kit tienen muy limitado su comunicación con el exterior, solo disponen de tres

leds y tres pulsadores conectados de manera fija al puerto D. Para mejorar esto se

incluye como opcional (yo diría imprescindible) una placa de expansión la DM320002:

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



http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545655



Para ello el Starter Kit dispone de un conector en la parte de atrás que permite su

conexión con la placa de expansión:



Y que nos permite tener acceso a todos los pines del Microcontrolador. En la figura de

abajo se muestra el Starter Kit ensamblado en la placa de expansión.

¿la cuestión es que kit elegir?

La placa de desarrollo Explorer 16 ó Starter Kit. Cualquiera de ellas sirve para empezar

a programar estos dispositivos, sin embargo personalmente he preferido el Starter Kit +

la placa de expansión. Este kit permite programar y depurar nuestro programa

directamente desde el MPLAB, sin necesidad de ningún programador adicional, para

ello el kit incluye el PIC18LF4550, que sirve para controlar la comunicación USB entre

el MPLAB y el PIC 32, además si tenemos la placa de expansión nuestro kit de

aprendizaje se convierte fácilmente en una placa para desarrollar prototipos ya que

podemos conectar cualquier placa que desarrollemos nosotros mismos directamente a

los pines del PIC, como veremos más adelante en el ejemplo que vamos hacer.

Software necesario

MPLAB: El famoso IDE de desarrollo de Microchip que ha utilizado desde

siempre para facilitar la edición y depuración de programas en los PIC de todas

sus familias. Aunque no es software libre es gratis y se puede descargar desde la

página de Microchip desde aquí

Compilador: los PIC32 son totalmente diferentes en arquitectura a sus

sucesores, en este caso Microchip en vez de desarrollar su propio núcleo de

microprocesador a adquirido el MIPS32 M4K, el cual ha mejorado y adaptado a

http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002ta

http://www.mips.com/products/processors/32-64-bit-cores/mips32-m4k/index.cfm#features



los puertos y periféricos que disponen todos los PIC. El MIPS32 está pensado

para ser programado en C, aunque es posible programar un PIC32 en

ensamblador y Microchip incluye algunos ejemplos de como hacerlo, es mucho

más difícil que hacerlo con uno de 8 bits. Compiladores de C disponibles para

estos PICs tenemos el de Microchip MPLAB C32 compiler que dispone de una

versión de estudiante cuya única limitación es que como máximo permite

generar 64 KB de código compilado. Como alternativa al compilador de

Microchip tenemos en C el que nos ofrece HI-TECH, que también dispone de

una versión Lite. De momento CCS no dispone de ninguna versión de

compilador que soporte estos dispositivos, es lógico pensar que tarde o temprano

se actualice si no quiere quedarse atrás con respecto a otros compiladores. Puede

que mucha gente piense que para las aplicaciones que hace con

microcontroladores no necesitará nunca un microcontrolador de 32 bits y que

con los que hay de 8 y 16 bits les llega mas que sobrado, sin embargo puede que

al final esta tecnología se abarate y acabe por imponerse y tengamos que utilizar

un PIC32, aunque solo sea para hacer parpadear un led (esto son solo

suposiciones mías), pero sin duda es algo a tener en cuenta a la hora de decidirse

a aprender a programar estos dispositivos.

Nota: Buscando en Internet encontré byvac un interprete en basic para PIC32.

El compilador que voy a utilizar en este primer ejemplo y en posteriores será el C32 de

Microchip.

Comenzando la instalación del Software

El kit de desarrollo Starter Kit incluye: la placa, el software, el cable USB de conexión

con el ordenador y el código fuente de varios ejemplos, es decir, todo preparado para

que en menos de media hora hayamos compilado y probado nuestro primer ejemplo.


http://www.htsoft.com/products/compilers/pic32-modes.php

http://www.pic32.byvac.com/pic32_basic.php



La instalación del software es de lo más sencillo, al estilo windows: siguiente->

siguiente y FIN.



Pulsamos sobre instalación desde el CD y el asistente nos indica las aplicaciones que se

van a instalar, según se muestra en la figura de abajo se instalará en nuestro ordenador:

el IDE MPLAB, el compilador C32 (versión de evaluación) y los proyectos de ejemplo.



Crear nuestro primer proyecto

Vamos a ver paso a paso como crear nuestro primer proyecto para PIC32, como

compilarlo con el compilador C32 y ejecutarlo en la placa Starter Kit.

1. Abrimos el MPLAB y seleccionamos Project --> Project Wizard...



2. Pulsamos siguiente para iniciar la creación del proyecto con el asistente.



3. En la siguiente ventana seleccionamos el tipo de PIC



4. Seleccionamos el compilador C32



5. Le damos el nombre a nuestro proyecto y lo guardamos en el directorio que

queramos.



6. Añadimos los archivos existentes a nuestro proyecto. Como vamos a crear un

proyecto desde cero, no añadimos ninguno y pulsamos sobre siguiente:



7. Pulsamos en finalizar para que el MPLAB nos genere los archivos de nuestro

proyecto

8. Ahora viene el paso más difícil, escribir el código fuente de nuestro primer programa

para el PIC32. Podría haber elegido uno de los que trae Microchip en los ejemplos del

kit. Pero teniendo en cuenta que sigue abierto el curso de programación PIC en C con el

compilador CCS y que no lo voy a dejar a medio, lo que voy hacer es adaptar los

ejemplos que vayamos realizando en el tutorial de CCS a este compilador. Esta claro

que no nos servirán las funciones pre-construidas que incorpora CCS, pero estamos

trabajando en C un lenguaje de alto nivel, veremos que todo lo que cumpla con el

estándar es aplicable a este compilador también.

Quizás la mayoría asocie las aplicaciones con PIC32 con aplicaciones avanzadas que

utilizan la pila de comunicación TCP/IP ó un ejemplo que incluya la comunicación con

un puerto USB 2.0. Sin duda con este tipo de aplicaciones es donde sacaremos el mayor

partido a estos microcontroladores, pero este va ha ser un tutorial que va a empezar

desde cero con este tipo de PIC, al estilo del curso de programación en C con CCS, por

lo que sus ejemplos trataran de como ir poco a poco utilizando los recursos de este PIC:

Puertos de E/S, timers, convertidores A/D, ejemplos con teclados, LCD, etc. Recursos



que son comunes a los PIC de categorías inferiores, pero que son imprescindible

conocer también en este tipo de PIC. Así que como primer ejemplo vamos a empezar

con uno que ya teníamos hecho, la secuencia de luces utilizando operadores

matemáticos

http://www.aquihayapuntes.com/component/content/article/44-ejemplos-basicos-de-pic-en-c/106-ejemplos-basicos-de-pic-en-c-secuencia-de-luces-utilizando-operadores-aritmeticos.html

http://www.aquihayapuntes.com/component/content/article/44-ejemplos-basicos-de-pic-en-c/106-ejemplos-basicos-de-pic-en-c-secuencia-de-luces-utilizando-operadores-aritmeticos.html



Iniciación a la programación de los PIC32 - Ejemplo secuencia de luces.

Para ello desde el MPLAB seleccionamos New File según se muestra en la figura de

abajo:

Nos aparecerá el cuadro de edición de programas, donde tendremos que escribir el

código fuente de nuestra aplicación:



En el escribiremos el siguiente código:

view source

print? 01.///////////////////////////////////////////////////// 02.// Ejemplo: Secuencia de luces. Coche fantástico // 03.// Microcontrolador: PIC 32 // 04.// IDE: MPLAB // 05.// Compilador: C32 // 06.// Autor: Biblioman // 07./////////////////////////////////////////////////////

08. 09.#include <plib.h> //Librería de periféricos

10. 11.void delay_ms(int valor);//Declaración función retardo

12. 13.//Función retardo 14.void delay_ms(int valor) 15. { 16. int i; 17. for(i=0; i<valor; i++); 18. }

19. 20.void main(void)//Función principal

http://www.aquihayapuntes.com/curso-pic32.html#viewSource

http://www.aquihayapuntes.com/curso-pic32.html#printSource

http://www.aquihayapuntes.com/curso-pic32.html#printSource



21. {

22. 23. TRISE = 0; // Toda la PORTD como salida 24. PORTE=1; //inicializo PORTE 25. delay_ms(150000);//llamada a la función retardo

26. 27. while(1) // Bucle infinito 28. {

29. 30. while(PORTE<=0x40) 31. { 32. PORTE=PORTE*2; 33. delay_ms(150000); 34. } 35. while(PORTE>=0x02) 36. { 37. PORTE=PORTE /2; 38. delay_ms(150000); 39. } 40. }

41. 42.}

Comentario del programa

Como veis el código no es tan diferente del empleado en CCS, vamos a ver las

diferencias que hay a la vez que empezamos a ver algunas características hardware de

estos nuevos PIC. En este ejemplo se hace uso de los puertos de entrada y salida. El PIC

32MX360F512L dispone de siete puertos de entrada y salida de 16 bits cada uno de

ellos distribuidos de la siguiente manera:

PIN Tipo

RA0-RA15 E/S

RB0-RB15 E/S

RC0-RC15 E/S

RD0-RD15 E/S

RE0-RE15 E/S

RF0-RF15 E/S

RG0, RG1,

RG4-RG15 E/S

RG2, RG3 E

Nuestro ejemplo solo utiliza 8 bits del puerto E, por lo que los otros ocho quedan

disponibles para otros menesteres.



Otro dato que tenemos que tener en cuenta es que estos microcontroladores utilizan una

interfaz nueva denominada JTAG que se encuentra multiplexada a través de los pines

RA0, RA1, RA4 y RA5 del puerto A. Esta interfaz la utiliza el Starter Kit para la

programación y depuración del PIC32 á través del PIC18, según se muestra en la figura

de abajo:

Estos pines vienen configurados por defecto para su uso con la interfaz JTAG, por lo

que no tendremos que configurarlos en nuestro código, salvo tener en cuenta que estos

pines están reservados y no los podremos utilizar en nuestros programas con esta placa

de desarrollo. La placa de desarrollo Explorer 16 utiliza los programadores/depuradores

ICD2 ó ICD3 y el MPLAB Real ICE a través del puerto ICSP/ICD. por lo que si se

podrían utilizar estos pines siempre y cuando se deshabilite previamente la interfaz

JTAG en el código de nuestro programa.

Dejemos de momento las características hardware, y volvamos al código de nuestro

ejemplo. La primera instrucción que nos encontramos es la directiva: #include <plib.h>

El archivo de cabecera plib.h incluye a su vez a otros archivos de cabecera donde están

definidas una serie de funciones y macros para facilitar el trabajar con todos los

periféricos del PIC. Microchip dispone de un manual de esta librería, Podemos utilizar

estas macros para el control de los puertos del PIC, pero también podemos utilizar el

método tradicional que permite usar identificadores para los registros del PIC y trabajar

con ellos directamente, al igual que hacíamos en CCS. En el ejemplo he utilizado esta

última opción para que el código se parezca más al hecho para CCS.

Otro cosa que hay que tener en cuenta es que este compilador no soporta la

representación de datos en binario, se soluciona rápidamente cambiando los valores a

hexadecimal (0b00000000 por 0x00), realmente la notación binaria es cosa de algunos



compiladores para microcontroladores incluyendo a CCS, ya que está notación no esta

soportada por el estándar ANSI C.

Por último como gran diferencia con respecto al código en CCS es que en C32 no existe

una función de retardo por software del tipo delay_ms() que tiene CCS. Por lo visto,

esto es debido a la arquitectura del núcleo MIPS32 M4K que hace que el número de

instrucciones ejecutadas por ciclo de reloj no sea constante, haciendo que no sea viable

la programación de retardos por software.

Para este primer ejemplo se ha utilizado un rudimentario retardo a través de un bucle

for. Los retardos precisos habrá que hacerlos utilizando los timers, para ello el PIC

32MX360F512L dispone de cinco timers y de un reloj en tiempo real RTCC (Real Time

Clock Calendar), que nos permite trabajar directamente con unidades de tiempo de

segundos, minutos, horas y fechas de manera fácil y precisa.

Esto son las diferencias que han sido necesarias aplicar para que funcione el programa

ya hecho en CCS, de la secuencia de luces tipo coche fantástico.

Una vez que tenemos escrito nuestro programa en la ventana de edición, debemos

agregar el archivo a nuestro proyecto, para ello seleccionamos File--> Save para guardar

nuestro programa, en la ventana que nos aparece escribiremos un nombre para nuestro

programa y que tenga por extensión .c, no hay que olvidarse de marcar la casilla "añadir

archivo al proyecto", según se muestra en la figura de abajo.



MPLAB nos permite depurar el programa a través de varias herramientas,

seleccionamos MPLAB SIM según se muestra en la figura de abajo.



Ahora ya lo tenemos todo preparado y llega el momento de compilar para comprobar

que nuestro programa no tiene ningún error, seleccionaremos la opción "build All" para

que MPLAB nos genere todos los archivos necesarios para ejecutar y depurar nuestro

programa.



Si nuestro programa se ha compilado sin errores, nos aparecerá en la ventana de salida

que nuestro proyecto se ha construido satisfactoriamente y a partir de ahora tendremos

habilitados los botones de simulación.



Hay que decir que los PIC32 todavía no están modelados en Proteus, por lo que no

dispondremos de esta herramienta de simulación para depurar nuestro programa,

cuestión de tiempo también, que los fabricantes de Proteus integren este nuevo PIC en

sus librerías.

Pero mientras tanto, tenemos MPLAB que también nos permite simular nuestro

programa paso a paso, crear Break Point, ver el estado de los registros del PIC y muchas

cosas mas.



Hasta aquí todo lo hecho se puede hacer sin tener que gastar un duro, utilizando las

herramientas gratuitas que nos ofrece Microchip.



Iniciación a la programación de los PIC32 - Simulación real del ejemplo.

Para el que se decida adquirir la placa de desarrollo a llegado el momento de probar

nuestro ejemplo en un circuito real, para ello he creado una pequeña placa prototipo con

ocho led y que se conectan a los 8 primeros pines del puerto E del PIC, a través de la

placa de expansión según se muestra en la figura de abajo:

Después solo nos queda conectar el Starter Kit a través del cable USB a nuestro

ordenador. Desde el MPLAB seleccionamos Debugger-> Select tool -> PIC32MX

Starter Kit



Si la conexión ha tenido éxito nos saldrá la caja de herramientas para programar y

depurar nuestro PIC, donde pulsaremos sobre Program All Memories para cargar

nuestro programa en el PIC. Si todo ha ido bien nos aparecerá: Programming Done en

la ventana de salida y a partir de ahora podremos ejecutar y simular paso a paso nuestro

programa desde el interior del PIC, igual que si tuviéramos conectado el

programador/depurador ICD3 de Microchip.

Aquí tenéis un pequeño vídeo del programa funcionando:

Ver vídeo.

http://www.youtube.com/watch?v=E2lraKVckuY



www.aquihayapuntes.com

Tutorial creado por Biblioman.

Versión 1.00

http://www.aquihayapuntes.com/curso-pic32.html

Portado a PDF por Meta.

http://electronica-pic.blogspot.com

Cualquier sugerencia, duda o cualquier comentario, puedes realizarla en el foro aquí:

http://www.aquihayapuntes.com/foro/viewtopic.php?f=20&t=46&sid=f3bb3a346d246efb53a

2c46f8363533e

Puede haber futuras actualizaciones, mejoras y contenidos.

http://www.aquihayapuntes.com/

http://www.aquihayapuntes.com/contactar.html

http://www.aquihayapuntes.com/curso-pic32.html

http://electronica-pic.blogspot.com/

http://electronica-pic.blogspot.com/

http://www.aquihayapuntes.com/foro/viewtopic.php?f=20&t=46&sid=f3bb3a346d246efb53a2c46f8363533e

http://www.aquihayapuntes.com/foro/viewtopic.php?f=20&t=46&sid=f3bb3a346d246efb53a2c46f8363533e