lunes, 26 de marzo de 2012

Desarrollo Portable con Launchpad

Hace poco que hablé sobre el Launchpad. Una pequeña placa de desarrollo que Texas Instruments vende, yo diría que por debajo del precio de coste, para demostrar la serie de Microcontroladores Value Line de la familia MSP430.

Launchpad v1.4

No me extenderé a hablar sobre la placa en sí, ya que para eso está mi anterior artículo. Lo que explicaré es la manera de poner en marcha un entorno de desarrollo bajo Windows, portable y tan open source como es posible, que nos permita programar el launchpad.
Existen entornos de desarrollo profesionales que disponen de licencias gratuitas, limitadas en tamaño de código, que permiten trabajar con el Launchpad. Entre ellas, el Code Composer Studio dispone de una licencia gratuita que llega justo a los 16 kBytes de Flash del microcontrolador MSP430G2553 incluido en los últimos Launchpad de versión 1.5. De hecho, actualmente, no hay ningún microcontrolador dentro de la serie value line de la familia MSP430 que tenga más de 16kBytes de Flash.
Por tanto, en rigor, no es necesario hacer nada de lo que viene a continuación para trabajar con el Launchpad. No obstante la opción propuesta tiene otras ventajas:

  • Pude emplearse para compilar programas para otros microcontroladores de la familia MSP430 que soportan más de 16kB de Flash.
  • Se trata de un entorno basado en Eclipse, lo cual es muy práctico para los que ya conocen este entorno de programación, a parte de la calidad que tiene el entorno Eclipse en si mismo. Usar el entorno Eclipse para todos los procesadores con que uno trabaja evita la necesidad de aprender distintos entornos de programación propietarios.
  • Se trata de un entorno portable. Esto es, se puede mover de un ordenador a otro en un pendrive o en un disco duro portátil.
Desgraciadamente también hay un par de inconvenientes:

  • Los ejemplos que proporciona Texas Instruments, y muchos ejemplos disponibles en internet, se han realizado para los dos entornos preferidos IAR Embedded Workbench o Code Composer Studio. Es por ello que normalmente tendrán que hacerse algunas modificaciones en el código para que compile usando las herramientas propuestas. Eso incluye, especialmente, el procedimiento de definición de las Rutinas de Servicio de Interrupcion.
  • Para depurar programas, o cargarlos en la placa Launchpad, son necesarios los drivers USB de la placa y un par de ficheros DLL se soporte. Estos elementos no son en absoluto de código libre, si bien se pueden obtener gratuitamente tal y como se explicará más adelante.

Sin más preámbulos, pasemos a la acción:


Material Necesario


Para empezar necesitamos el entorno Eclipse Indigo. Se puede descargar de la página de descargas de Eclipse http://www.eclipse.org/downloads/


En mi caso el fichero es eclipse-cpp-indigo-SR2-incubation-win32.zip

Luego necesitamos el compilador gnu para msp430, lo encontraremos en la página de Sourceforge para el proyecto mspgcc http://sourceforge.net/projects/mspgcc/



Pulsamos el boton donwload y con ello descargamos el fichero zip que en mi caso es
mspgcc-20110716-p20120311.zip

Desgraciadamente esta distribución no contiene las utilidades make y rm que necesitamos para compilar los programas. Estas las obtendremos de Unxutils. El vínculo de descarga es:

De ello obtenemos el fichero UnxUtils.zip

Para poder depurar los programas necesitamos un servidor GDB y drivers USB para la placa Launchpad. Una parte del servidor GDB es de código libre y la otra parte, y los drivers USB, son propietarios.

La parte libre es el fichero msp430-gdbproxy.exe que podemos obtener de:

http://sourceforge.net/projects/mspgcc/files/Outdated/msp430-gdbproxy/2006-11-14/


No me consta ningún servidor GDB completo de código libre que pueda depurar aplicaciones sobre el Launchpad bajo Windows. Por tanto, tendremos que recurrir a algunos ficheros que se incluye en alguna aplicación comercial con licencia limitada gratuita.

La opción más sencilla es instalar IAR Embedded Workbench KickStart. Esta aplicación puede bajarse de http://www.ti.com/lit/zip/slac050. Una vez instalado necesitamos 2 cosas:

  • Drivers que permiten a Windows reconocer la placa Launchpad cuando se conecta al puerto USB. Estos drivers se hallan, después de instalar IAR Embedded Workbench, en 
        C:\Archivos de programa\IAR Systems\Embedded Workbench 6.0 Kickstart\430\drivers\TIUSBFET 
  
  • Ficheros msp430.dll y hil.dll que permiten la carga y depuración de código. Estos ficheros se hallan, después de instalar IAR Embedded Workbench, en 
         C:\Archivos de programa\IAR Systems\Embedded Workbench 6.0 Kickstart\430\bin

Actualización a 25/4/2012

Los ficheros  msp430.dll y hil.dll pueden obtenerse del fichero slac435b.zip de Texas Instruments.
Este fichero contiene la apliación Demo que viene preprogramada en el Launchopad.
Los ficheros de interés se hallan en el siguiente directorio dentro del fichero ZIP:

\MSP-EXP430G2-Launchpad User Experience\bin\MSP-EXP430G2-LaunchPad

Una vez tenemos estos ficheros, podemos dejar instalador IAR Embedded Workbench, si deseamos usar este entorno, o podemos desinstalarlo si sólo deseamos usar un entorno basado en Eclipse.

Existe una manera alternativa de obtener estos ficheros pero me parece demasiado complicada. Para los curiosos se puede obtener siguiendo los pasos que se explican aqui

Despues de todo el proceso tenemos que tener los siguientes elementos:

  • eclipse-cpp-indigo-SR2-incubation-win32.zip
  •  mspgcc-20110716-p20120311.zip
  • UnxUtils.zip
  •  msp430-gdbproxy.exe
  • Ficheros msp430.dll y hil.dll
  • Carpeta de drivers TIUSBFET de la placa Lauchpad 
Ya podemos empezar, pues, a instalar todo esto.


Preparando el disco externo

Como comenté anteriormente, la idea es disponer de un entorno portable de programación. Para ello resulta conveniente que el disco duro o pendrive que lo contiene se identifique siempre ante el sistema operativo con la misma letra de unidad. En mi caso he elegido emplear la letra "M", de manera que el disco se identificará siempre como M:

Si se desea instalar el entorno de programación de manera no portable, basta con saltar el resto de este apartado y emplear C: en todos los sitios donde diga M: del resto de este artículo.

Para cambiar la letra de una unidad, hemos de emplear el administrador de discos. Para acceder a él, en Windows XP, pulsamos el botón derecho sobre el icono Mi PC y seleccionamos Administrar.



Pulsamos sobre Administración de discos y, a continuación, pulsamos el botón derecho sobre el disco externo que queremos emplear para instalar el entorno de trabajo. Elegiremos Cambiar la letra y rutas de acceso de unidad...


Cambiaremos la letra a la que deseemos. Si se elige una letra que no sea "M", se tendrán que cambiar en consecuencia todas las referencias de directorios del resto de esta explicación.

En adelante, si no pasa nada extraño, el disco siempre se identificará en ese ordenador con la misma letra elegida. Este procedimiento se ha de repetir en cada ordenador donde se dese usar el entorno de programación portable.


Preparando los directorios

 Actualmente tengo en mi disco portátil 4 entornos de programación. Un entorno para Arduino, un entorno para PIC32-Pinguino, un entorno para STM32 bajo Eclipse y el entorno para MSP430 bajo Eclipse que es objeto de este artículo. Con objeto de evitar tener muchos directorios colgando de la raiz del disco, todos los entornos están dentro de M:\MCU

Dentro de M:\MCU crearemos un directorio msp, y dentro de éste pondremos la carpeta eclipse que se halla dentro del fichero eclipse-cpp-indigo-SR2-incubation-win32.zip.
A continuación crearemos 3 directorios dentro de M:\MCU\msp con nombres gdb proxy , mspgcc y workspace.
Dentro del directorio gdb proxy pondremos los ficheros msp430-gdbproxy.exe, msp430.dll y hil.dll
Dentro del directorio mspgcc pondremos el contenido de mspgcc-20110716-p20120311.zip
A continuación abriremos el fichero UnxUtils.zip y buscaremos la carpeta usr\local\wbin\ y tomaremos los ficheros make.exe y rm.exe y los pondremos dentro de M:\MCU\msp\mspgcc\bin
El directorio workspace, de momento, lo dejamos vacío.

Finalmente abriremos la carpeta M:\MCU\eclipse y pondremos un acceso directo del fichero eclipse.exe sobre la carpeta M:\MCU y lo renombraremos eclipse-msp430

Al final nos ha de quedar una estructura de directorios como la que sigue:


Probando Drivers y servidor GDB

Antes de comenzar a configurar Eclipse conviene comprobar que la instalación de los drivers y del Servidor GDB es correcta. Si no lo hemos hecho ya, instalaremos los drivers TIUSBFET que permiten acceder a la placa Launchpad. Si se ha probado exitosamente la programación de algún ejemplo de los que vienen con IAR Embedded Workbench KickStart, significa que los drivers se han instalado correctamente.

En todo caso, la mejor manera de comprobarlo es enchufar la placa Launchpad a uno de los puertos USB disponibles y abrir el Administrador de dispositivos de Windows.

En Windows XP: MiPC -> Administrar -> Administrador de dispositivos
o en Panele de Control -> Herramientas Administrativas -> Administrador de equipos

En Windows 7 lo podemos hallar dentro del panel de control



Debería aparecer MSP430 dentro Puertos (Com & LPT)




Una vez que vemos que se reconoce correctamente, abrimos una ventana de comandos, nos vamos a
M:\MCU\msp\gdb proxy 
y ejecutamos
msp430-gdbproxy msp430 --spy-bi-wire TIUSB

debería aparecer una pantalla como la siguiente:




Una vez verificado que funciona el servidor GDB, lo apagaremos con Ctrl+C

Configurando Eclipse

Una vez que sabemos que el debugger funciona, podemos empezar a configurar eclipse. Abrimos eclipse con el acceso directo que creamos anteriormente en M:/MCU y nos aparecerá una ventana solicitando el workspace que deseamos usar. Emplearemos el directorio:
M:\MCU\msp\workspace
Si no deseamos que nos vuelva a preguntar sobre ello, podemos seleccionar la casilla "Use this as the default folder for this session"


Nos aparecerá la ventana principal de eclipse. Antes de continuar hemos de instalar en eclipse el soporte para Debug GDB, para ello seleccionaremos Install New Software... dentro del menú Help.
Dentro de "Work with" elegiremos la opción desplegable --All Available Sites--
En la casilla de búsqueda que hay debajo podremos GDB Hardware debugging
Nos saldrá la opción C/C++ GDB Hardware Debugging y la seleccionaremos con el cuadro que hay a su izquierda. A continuación pulsamos Next.


Aceptamos la licencia y pulsamos Finish


A continuación permitiremos que eclipse vuelva a arrancar antes de continuar


Con ello volvemos otra vez a la pantalla principal de eclipse. Si nos aparece la pantalla que se muestra a continuación, pulsaremos sobre la X recuadrada en rojo.


Con ello tendremos la vista normal para desarrollo C/C++ en eclipse.



Creando un proyecto

 Para hacer el resto de configuraciones, crearemos un nuevo proyecto sencillo que hará parpadear un led en la placa Launchpad. Para ello Elegimos New->C Project


En "Project name" pondremos Blinky
Seleccionaremos Cross-Compile Project y Cross GCC y pulsaremos Next


En "Tool Command prefix" pondremos msp430-
En "Tool Command path" pondremos M:\MCU\msp\mspgcc\bin


Con ello tendremos un nuevo proyecto Blinky tal y como se muestra en la figura.


Deseamos crear una carpeta para los ficheros fuentes dentro del proyecto. No es estrictamente necesario pero ayuda a tener las cosas ordenadas. Para ello seleccionaremos el proyecto Blinky y, apretando el botón derecho del ratón abriremos el menú contextual con el que seleccionaremos New->Folder


Pondremos src en "Folder name" y pulsaremos Finish


Ahora crearemos el fichero main.c, para ello abriremos el menú contextual sobre la carpeta src y elegiremos New->File


Con ello aparecerá una pantalla como la que se muestra a continuación.


Pondremos main.c en "File name" y pulsaremos Finish

Con doble click abriremos el fichero main.c recien creado y copiaremos dentro el siguiente texto:


/* main.c */

// Include the register definitions. Note that we do not
// use a device specific include file, the compiler handles
// that based on the -mmcu option

#include <msp430.h>
#include <msp430g2231.h>

int main()    // The main function
 {          
 //volatile unsigned int i = 0;
 unsigned int i = 0;

 // Disable the watchdog.
 // The watchdog is on by default on an     * MSP430,
 // if we do not disable it it will reset the CPU
 // after * 32k cycles in the standard configuration. */

 WDTCTL = WDTPW + WDTHOLD;

 // set P1.0 as output
 P1DIR = BIT0;

 // do forever:
 while (1)
     {
     i++;
     if (i == 0)
          {
          // Flip the value of P1.0's output register
          // when i * overflows to zero
          P1OUT ^= BIT0;
          }
     }
  }

La ventana debería quedar más o menos así:




Configurando el proyecto

Ya tenemos el proyecto con todo su código. Lo que resta, que no es poco, es configurar eclipse para que sepa como compilarlo.

Comenzaremos eligiendo Properties en el menu contextual del proyecto Blinky
Abriremos el desplegable C/C++ Build de la subventana izquierda y seleccionaremos Includes bajo Cross GCC Compiler. Pulsaremos la casilla "+" y añadiremos el path:
M:\MCU\msp\mspgcc\msp430\include


A continuación seleccionaremos Miscellaneous dentro de Cross GCC Compiler y escribiremos la información sobre el procesador para el que se desea que trabaje el Compilador dentro de "Other flag"

-c -fmessage-length=0 -mmcu=msp430g2231

La línea anterior corresponde al procesador que viene en el Launchpad v1.4. Existen un total de 4 procesadores distintos en la plataforma launchpad dependiendo de si es la versión 1.5 o anterior y dependiendo de si es el procesador que viene montado en la placa o el otro que viene en una bolsita antiestática. En la línea anterior se ha de ponder el que pertoque:

-mmcu=msp430g2231  MCU montado en launchpad v1.4 y anteriores
-mmcu=msp430g2211  MCU en bolsita en launchpad v1.4 y anteriores

-mmcu=msp430g2553  MCU montado en launchpad v1.5
-mmcu=msp430g2452  MCU en bolsita en launchpad v1.5

En todo caso el fichero main.c, dado que tiene una línea:
#include <msp430g2231.h>
hace referencia a la primera opción. Caso de emplearse otro procesador, también se ha de cambiar la línea #include


El Linker también se debe configurar. Se hará eligiendo Miscelaneous bajo Cross GCC Linker.

Elegiremos el mismo procesador elegido para el compilador y, añadiremos también un flag que hará que se genere el fichero linker.map. Este fichero es opcionaly nos permite saber como queda el código dentro del mapa de memoria del microcontrolador.
Para el caso del MSP430G2231 los flags quedan así:

-mmcu=msp430g2231 -Wl,-Map=linker.map,--cref


A continuación fijaremos la configuración del Ensamblador de manera similar a la realizada para el Compilador. Seleccionaremos General bajo Cross GCC Assembler y pondremos:

Flags: -mmcu=msp430g2231 (u otro Microcontrolador si hace falta)
include: "M:\MCU\msp430\mspgcc\msp430\include"



A continuación hemos de añadir algun path para los includes. Para el proyecto Blinky no es necesario, ya que no tiene includes en el directorio src, pero es buena idea hacerlo para no olvidarlo en otros proyectos más complejos. Seleccionaremos el la subventana izquierda C/C++ General -> Paths and Symbols.
Seleccionamos GNU y miramos que aparezca el path
M:\MCU\msp430\mspgcc\msp430\include
tal y como se muestra en la siguiente ventana.
Es posible que aparezcan mas directorios pero no os preocupeis por ellos.



A continuación pulsamos el botón Add... para añadir otro path.
Escribiremos  /${ProjName}/src y nos aseguramos de que is a workspace path esté seleccionado
A continuacion pulsaremos OK


A continuación hemos de indicar en que directorios se hallarán los ficheros C que se deben compilar. Para ello seleccionaremos la pestaña "Source Location" y verificaremos que se hallen los directorios /Blinky y /Blinky/src. Si falta alguno, lo añadiremos con el botón Add Folder...


El siguiente paso es opcional. En la pestaña "Build Steps" dentro de C/C++ Build -> Settings es posible indicar programas que se han de ejecutar antes y después de Compilar. En la figura siguiente se muestra que se ha añadido un comando Post-build, esto es, que se ejecutará después de compilar.
Command: msp430-size  "${ProjName}
Description: Project Size
Este comando hará que después de compilar se muestre en la cónsola el espacio ocupado por el código. De esta manera es fácil saber si se está alcanzando el límite disponible en el microcontrolador elegido.


Pulsamos OK y con ello acaba la configuración del proyecto Blinky.

Compilando el proyecto

Una vez acabada la configuración del proyecto, podemos pasar a compilarlo. Para ello Elegiremos Build Project dentro del menú Project.


Si todo va bien debería acabar la compilación correctamente y mostrarse el tamaño del binario generado que en nuestro caso es de 142 bytes.



Carga y depuración del programa

Para cargar y depurar el programa en la placa Launchpad emplearemos el Servidor GDB que probamos previamente. Lo arrancaremos desde la interfaz de usuario de Eclipse, para ello seleccionaremos External Tools Configurations... dentro del menú de herramientas (Un triángulo y una maleta).


Seleccionaremos Program y pulsaremos el botón "+"



Rellenaremos las siguientes casillas:

En "Name" pondremos GDB Server
En "Location" buscaremos con Browse File System... el lugar donde se halla instalado el servidor GDB
M:\MCU\msp\gdb proxy\msp430-gdbproxy.exe
En Arguments pondremos: msp430 --spy-bi-wire TIUSB


Despues de ello pulsaremos Run y debería aparecer un mensaje como el que sigue indicando que el servidor GDB está en marcha.


Una vez que tenemos el servidor GDB, hemos de de crear una sesión de debug para el proyecto Blinky

Seleccionaremos Debug Configurations... dentro del menú de Debug (Un Escarabajo)



Allí seleccionaremos GDB Hardware Debugging y pulsaremos "+"


Rellenaremos los campos:

Name: Blinky Debug
Project: Seleccionaremos Blinky con Browse...
C/C++ Application: Seleccionaremos Debug/Blinky con Browse...


Seleccionaremos ahora la pestaña "Debugger" y rellenaremos los campos:

GDB Command: msp430-gdb
Port Number: 2000


Seleccionamos la pestaña "Startup" y añadimos la siguiente linea a la ventana de comandos:
monitor erase main
Seguidamente pulsamos el botón Debug


El programa se cargará en la placa y Eclipse nos recomendará cambiar a la perspectiva de Debug. Pulsaremos Yes para aceptar.


Aparecerá la perspectiva de Debug. Usando esta perspectiva es posible depurar el programa mediante ejecución paso a paso, visualización de variables y establecimiento de breakpoints.
De momento arrancaremos el programa con el botón de ejecución que se muestra en la siguiente ventana.
El led de la placa launchpad debería empezar a parpadear.


Mientra corre el programa están disponibles los distintos botones de control de depuración y podemos observar el valor de las variables y el punto donde se ha detenido el programa debido a un breakpoint o a la pulsación del botón de pausa. La explicación sobre como hacer la depuración lo dejaremos para otro artículo.


Cuando acabemos de ejecutar el programa, podemos pararlo mediante el botón de parada (Rectángulo rojo). No nos olvidemos de parar también el servidor GDB cuando acabe el proceso de depuración.


Hasta aquí todo lo necesario para compilar y depurar programas. Lo que queda del artículo es completamente opcional.


Comandos adicionales (Opcional)

 Es posible añadir herramientas adicionales a eclipse. A continuación explicaré como añadir herramientas para ver el tamaño de todo un proyecto o uno de sus componentes.

Crearemos una nueva herramienta externa igual que lo hicimos con el servidor GDB, pero en este caso pondremos los siguientes valores:

Name: Project Size
Location: M:\MCU\msp\mspgcc\bin\msp430-size.exe
Working Directory: ${project_loc}/Debug
Arguments: ${project_name}
 


Ejecutaremos este comando seleccionando previamente uno de los proyectos. Blinky, por ejemplo.


El resultado aparecerá en la consola.


El comando anterior es para saber el espacio total asociado a un proyecto. Para saber el espacio ocupado por uno de los ficheros objeto, podemos crear otra herramienta.

Name: Resource Size
Location: M:\MCU\msp\mspgcc\bin\msp430.size.exe
Working Directory: ${container_loc}
Arguments: ${resource_loc}



Este comando lo podemos usar seleccionando previamente cualquier fichero objeto.


El resultado aparecerá en la consola


Las dos aplicaciones que hemos añadido son accesibles, después de su primera ejecución, en el menú contextual de aplicaciones externas.



Creación de otros proyectos

Para crear otro proyecto, la opción más sencilla es seleccinar el proyecto Blinky y pulsar Ctrl+C seguido de Ctrl+V. Con ello aparecerá una ventana que nos permitirá dar nombre al nuevo proyecto que será un clon del proyecto Blinky. Por tanto, no será necesario volver a configurarlo y bastará modificarlo para las nuevas necesidades del proyecto.

Para dejar limpio el nuevo proyecto haremos los siguientes pasos:

Deseleccionaremos Build Automatically del menú Project
Elegiremos Clean... en el menú Project, comprobaremos que se halla seleccionado el nuevo proyecto y pulsaremos OK.

Adicionalmente podemos borrar los ficheros adicionales del directorio Debug como linker.map

Con ello tendremos un proyecto vacío y configurado con el que empezar una nueva apliacación.

Referencias

La siguiente página me ha sido de mucha utilidad para desarrollar todo lo explicado en este artículo