Iniciación a la programación de los PIC32
Mini-curso de iniciación a la programación de los PIC32
MICROCONTROLADORES
Biblioman
1/9/201012 min read
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:
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 X: 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 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 MPLAB C32 compiler de Microchip 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, HI-TECH (Recientemente adquirido por Microchip) 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.
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
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:
/////////////////////////////////////////////////////
// Ejemplo: Secuencia de luces. Coche fantástico //
// Microcontrolador: PIC 32 //
// IDE: MPLAB //
// Compilador: C32 //
// Autor: Biblioman //
/////////////////////////////////////////////////////
#include <plib.h> //Librería de periféricos
void delay_ms(int valor);//Declaración función retardo
//Función retardo
void delay_ms(int valor)
{
int i;
for(i=0; i<valor; i++);
}
void main(void)//Función principal
{
TRISE = 0; // Toda la PORTD como salida
PORTE=1; //inicializo PORTE
delay_ms(150000);//llamada a la función retardo
while(1) // Bucle infinito
{
while(PORTE<=0x40)
{
PORTE=PORTE*2;
delay_ms(150000);
}
while(PORTE>=0x02)
{
PORTE=PORTE /2;
delay_ms(150000);
}
}
}
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:
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.
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: