Mipixel

Tras mucho tiempo sin escribir en el blog hoy voy a colgar aquí el video de la charla que he dado en Campus Party Valencia. Hay que dar las gracias a la organización y a A.R.D.E. por haberme ofrecido la oportunidad.

En esta segunda parte me gustaría orientar un poco sobre las distintas opciones que tenemos a la hora de compilar código para la familia STM32 de STMicroelectronics, de la que ya se ha hablado en la anterior entrada del blog.

Al llegar aquí encontramos muchos IDEs distintos, muchos compiladores, JTAGs, depuradores, emuladores y cientos de cosas más. Esto al principio puede confundir, así que este artículo solo pretende poner un poco de orden a las cosas y así saber qué es lo que más nos interesa.

En primer lugar nos detendremos en los compiladores. Estos microcontroladores están pensados para ser programados en C, por lo que el ensamblador lo descartaremos salvo que necesitemos un control muy preciso de los tiempos en la aplicación. En cualquier caso la mayoría (por no decir todos) de compiladores de C admiten la inserción de código en ensamblador en el código a compilar, por lo que no será un problema.

Empezaremos por el conjunto de herramientas que STMicroelectronics ofrece con su kit Primer 2, se trata de la suite de Raisonnace compuesta por el IDE Ride7 y el RKit-ARM, que no es más que el compilador GCC de GNU. El IDE lo ofrecen de forma totalmente gratuita y sin ningún tipo de limitación en cuanto a tamaño de código u optimizaciones. En cualquier caso, tendremo que adquirir un adaptador RLink en caso de querer depurar el código en flash o en RAM. La versión estandar del RLink cuesta 99€ y solo permite depurar un máximo de 32KB. La versión profesional, sin limitaciones, cuesta 750€, una cantidad muy elevada. Podemos añadir al entorno las librerías ofrecidas por STMicroelectronics.

Otra opción muy usada, sobre todo por gente aficioanda, es CrossWorks for ARM de Rowley Associates. Podemos descargar gratuitamente una versión de prueba de 30 días, y si luego nos gusta, podemos adquirir por 150$ una licencia de uso personal. La ventaja de este IDE es que podemos usar muchos adaptadores distintos para depurar y programar el código en nuestros microcontroladores, por lo que no estaremos atados a un costoso adaptador para poder depurar todo el código, aunque si queremos podemos adquirir junto a la licencia un adaptador de la propia empresa, el CrossConnect Lite for ARM (60$) o la versión Classic (200$) que tiene mayor velocidad. Al igual que el Ride7, este IDE usa el compilador libre de GNU, GCC. También se le pueden incorporar fácilmente las librerías de STMicroelectronics. También incluye una librería propia de multitarea, pero esto es motivo de otra entrada en el blog.

Una opción que es totalmente libre, sería usar GCC con nuestro editor favorito, como Emacs, VIM, Kate o gedit, pero la realidad es que se echan en falta algunas opciones. Esto es fácil de solucionar si usamos como IDE a Eclipse y como depurador al proyecto OpenOCD. Eclipse podemos descargarlo gratuitamente desde su web, posteriormente habrá que instalarle algún añadido para que tenga soporte de C/C++. También necesitaríamos tener los archivos que se usan durante el proceso de linkado, por lo que tendremos que buscarlos o escribirlos nosotros mismos. Afortunadamente, ya hay soluciones que te instalan todo esto mucho más fácilmente y son las que a continuación comentaré.

La primera sería la que proporciona CodeSourcery. Esta empresa es la que más aporta al proyecto GCC para la arquitectura ARM. Al aportar código para GCC lo hacen bajo una licencia GNU, lo cual nos permite disponer del código fuente (por eso los anteriores usaban también este compilador, pero con su propia interfaz). De forma totalmente gratuita podemos descargar el compilador, así como las herramientas básicas para poder compilar código desde la línea de comandos. Normalmente lo encontraremos con el nombre de Sourcery G++ Lite Edition. Si queremos disponer de algo más, podemos adquirir una de las distintas licencias que tienen, y que van desde 99$ para la versión académica, hasta 2799$ para la Professional. Estas versiones incluyen además de lo anterior, el IDE Eclipse preparado para depurar y compilar código para Cortex-M3. Además incluyen librerías para iniciar los dispositivos, herramientas para disminuir el tamaño del código generado, facilidades para depurar, librerías para run-time optimizadas, etc. Además, podremos usar muchos JTAGs distintos.

Otra opción sería usar Yagarto. Yagarto cosiste un toolchain que integra de forma sencilla Eclipse, GCC y OpenOCD. Está disponible  de forma totalmente gratuita para Windows y MacOS X. También podemos usar casi cualquier JTAG para depurar y bajar código a nuestro dispositivo mediante OpenOCD. El gran problema, es que no trae ni ficheros Makefile ni los scripts de linkado, así que hay que buscarlos de otros proyectos o escribirlos nosotros.

Por suerte, hace poco surgió un nuevo proyecto llamado CooCox. Al igual que los anteriores usa como compilador GCC, pero usa su propio IDE basado en eclipse al que han nombrado como CoBuilder. Para depurar usan CoDebugger, que soporta varios JTAGs basados en el integrado FT2232. También ofrecen en forma de harware libre un adaptador para depurar código llamado CoLink, que también podemos adquirir por 19$ y que también podemos usar con la utilidad CoFlash (también tienen plugins para poder usarlo con otros entornos de pago), esta utilidad permite grabar código tanto en la flash de los Cortex-M3, como en la de otros dispositivos flash, ya que podemos personalizar el algoritmo de grabado. Complementariamente ofrecen un sistema operativo en tiempo real y con capacidad de multitarea bajo una licencia BSD, por lo que se trata de software libre, pero esto es parte de otro post al igual que ya comenté en el caso de CrossWorks.

Cabría destacar de este proyecto la facilidad de uso, ya que trae integradas las librerías de periféricos que ofrecen Atmel, STMicroelectronics, Luminary y NXP, además podemos ver ejemplos de los módulos, la documentación de las funciones, etc. También vienen ya integrados los scripts de linkado y la compilación se hace automáticamente sin tener que escribir un makefile. Además todo esto de forma totalmente gratuita y sin limitaciones.

Hasta aquí los entornos que usan GCC, ahora comentaré un par más de opciones que usan un compilador propio. El primero de ellos se trata del famoso IAR Embedded Workbench® for ARM, conocido como EWARM. Trae un compilador de C/C++ propio totalmente integrado con su respectivo IDE, soporta miles de dispositivos, trae más de 1700 ejemplos para placas de desarrollo de distintos fabricantes, librerías, scripts de linkado, etc. Todo lo que cabría esperar de un producto de IAR. Destacar que trae compatibilidad con un muchos JTAGs distintos, cosa de agradecer, y también soporta multitud de los RTOS existentes. Otra cosa que llama la atención es el plugin que ofrecen para integrar su compilador con Eclipse.

Podemos desacar una demo sin limitaciones de 30 días si nos registramos. Si queremos posteriormente adquirirla, he encontrado 2 versiones, la baseline por 2540€ y la estandar por 4484€ (precios de mouser), da miedo enh. Por suerte, existe una versión gratuita llamada KickStart, cuya limitación es que solo podemos hacer aplicaciones con menos de 32KB.

Para el final he dejado las herramientas que ofrece ARM bajo la firma Keil y que podríamos llamarlas como "las herramientas oficiales". Básicamente es más de lo mismo aunque destacaría el rendimiento de su librería microlib, que es muy superior a otras. Además de RealView, que son las herramientas de compilación, linkado y ensamblado, ofrecen un IDE llamado µVision. Ofrecen un paquete que trae todo lo necesario llamado MDK con dos versiones, estandar, sin limitaciones, y basic, limitada en debug y programación a 256KB. También hay versiones de prueba de 30 días. No he encontrado precios ni he investigado mucho más, ya que seguramente se trate de una herramienta tan cara como la del caso anterior.

Estos entornos solo son los más populares, pero creo que bastará para que cualquiera pueda hacerse una idea de la gran cantidad de software disponible, sus limitaciones y sus virtudes. De momento yo, como novato, me quedo con el proyecto CooCox aunque no se si compraré el CoLink u otro JTAG compatible, ya que los gastos de envío son un poco elevados.

Aquí dejo las sencillas instrucciones a seguir para quién quiera empezar a probar OpenCV. Para los que no lo sepan, OpenCV es un conjunto de librerías abiertas, mantenidas en gran parte por Intel, que nos ayudan a realizar tareas de visión artificial.

En GNU/Linux no debería de haber problemas con la instalación, pero en Windows me costado un poquito hasta que lo he tenido todo funcionando, y como no lo he encontrado en ninguna página, lo dejo aquí puesto.

Lo primero será descargar la versión de Eclipse preparada para C/C++, es lo mismo que si instalamos el IDE sin nada más y luego la parte del proyecto CDT. La forma fácil es ir a http://www.eclipse.org/downloads/packages/ y seleccionar "Eclipse IDE for C/C++ developers". La instalación es simple, descomprimir y listo.

Lo segundo que tendremos que instalar es MinGW. Se trata de un entorno que nos permitirá usar las utitlidades de compilación de GNU bajo Windows. El problema es que actualmente, la versión estable de MinGW usa gcc 3.4.x y para poder compilar usando las librerías de OpenCV 2.0 necesitaremos una versión más actual de GCC. Para ello la solución fácil es descargar el "TDM's GCC/MinGW32 build", que no es más que una versión alternativa con la versión 4.4.x de GCC y sus utilidades. Nos aseguraremos de desmarcar la casilla del make, ya que lo instalaremos como parte de otro paquete.

Ahora tendremos que instalar MSYS. Es un conjunto de herramientas que nos permitirá tener una consola simlar a la que tendríamos en GNU/Linux. Podremos además invocar a las herramientas más habituales de GNU, como make. Para ello vamos a http://sourceforge.net/projects/mingw/files/ y seleccionamos "MSYS Base System -> Current Release xxxx -> MSYS-xxxx.exe" y nos lo descargamos. Para instalarlo simplemente seguir el proceso de instalación. Al final si se nos abre una terminal preguntando, le respondemos y y pulsamos intro, después nos preguntará la ruta de MinGW pero con la barra hacia delante (/), en mi caso he puesto c:/mingw. Tras esto finalizará la instalación.

Nos queda instalar OpenCV, para ello simplemente desde su página web descargamos el instalador para Windows. En mi caso he desmarcado la casilla de "Source" ya que no me interesa.

Ya tenemos todo instalado, ahora abriremos Eclipse. Cuando se abra nos preguntará por el directorio de trabajo, simplemente le damos a Ok y seguimos. Si es la primera vez que lo ejecutamos, saldrá una pantalla de bienvenida, simplemente cerramos esa pestaña. Después nos vamos a "File->New->C++ Project" y se nos abrirá el asistente de proyectos. Le ponemos un nombre a nuestro proyecto y seleccionamos "Empty Project" de la lista. Como toolchain debemos seleccionar MinGW y pulsamos Next. En el siguiente diálogo pulsamos sobre el botón de "Advanced settings". En esta nueva ventana tendremos que seleccionar "GCC G++ Compiler -> Directories -> Include paths (-I)" y pulsar el botón de añadir. Seleccionamos "File system" y elegimos el directorio include/opencv que está dentro del directorio donde instalásemos OpenCV. En "MinGW C++ Linker -> Libraries -> Libraries (-l)" añadiremos las palabras highgui200, cv200 y cxcore200. Debajo en "Library search path (-L)" seleccionamos el directorio lib que está dentro de donde instalásemos OpenCV. Pulsamos en OK y Finish.

Ahora deberíamos de ver nuestro proyecto abierto a la izquierda y debería de estar listo para compilar. Haremos una prueba para ver que todo funciona, pulsamos con el botón derecho sobre el nombre del proyecto y seleccionamos "New -> Source folder", le ponemos de nombre src. Luego de la misma forma creamos un nuevo fichero de código en este directorio, le llamamos main.cpp. Ahí copiarémos el siguiente código de ejemplo:

////////////////////////////////////////////////////////////////////////
//
// hello-world.cpp
//
// This is a simple, introductory OpenCV program. The program reads an
// image from a file, inverts it, and displays the result.
//
////////////////////////////////////////////////////////////////////////
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cv.h>
#include <highgui.h>

int main(int argc, char *argv[])
{
IplImage* img = 0;
int height,width,step,channels;
uchar *data;
int i,j,k;

if(argc<2){
printf("Usage: main <image-file-name>\n\7");
exit(0);
}

// load an image
img=cvLoadImage(argv[1]);
if(!img){
printf("Could not load image file: %s\n",argv[1]);
exit(0);
}

// get the image data
height    = img->height;
width     = img->width;
step      = img->widthStep;
channels  = img->nChannels;
data      = (uchar *)img->imageData;
printf("Processing a %dx%d image with %d channels\n",height,width,channels);

// create a window
cvNamedWindow("mainWin", CV_WINDOW_AUTOSIZE);
cvMoveWindow("mainWin", 100, 100);

// invert the image
for(i=0;i<height;i++) for(j=0;j<width;j++) for(k=0;k<channels;k++)
data[i*step+j*channels+k]=255-data[i*step+j*channels+k];

// show the image
cvShowImage("mainWin", img );

// wait for a key
cvWaitKey(0);

// release the image
cvReleaseImage(&img );
return 0;
}

Guardamos el fichero y pulsamos en el icono de compilar . Abajo nos indicará si hay algún problema o si todo ha ido correctamente. En caso de que todo haya ido bien, podremos probar el ejemplo, para ello primero tendremos que copiar una imagen al proyecto y después pulsar en botón de Run . Saldrá debajo el texto "Usage: main <image-file-name>", para solucionarlo pulsamos en la flechita de la derecha del icono de Run, y elegimos Run configurations, después seleccionamos la pestaña de Arguments y escribimos en el cuadro de texto el nombre de la imagen que hallamos copiado al proyecto, guardamos y volvemos a ejecutar.

Esto es todo, ahora ya solo queda buscar un buen libro o tutorial y empezar a probar con nuestro entorno de desarrollo.

Una de las cosas que veo necesarias para que JALv2 gane público es que sea fácilmente integrable con MPLAB, el IDE gratuito de Microchip. Si descargamos JALv2 desde su página web veremos que hay unos fichero que sirven para integrar JALv2 con MPLAB, pero ni las instrucciones son correctas ni el MPLAB lo detecta. Es por eso que me puse manos a la obra y ya lo tengo funcionando. Aquí explicaré paso a paso cómo conseguirlo.

Lo primero será descargar desde la página de JALv2 el empaquetado con los binarios y resto de ficheros: http://www.casadeyork.com/jalv2/archive/jalv24l.zip

Al descomprimirlo veremos un directorio llamado mplab en cuyo interior encontramos los ficheros JALV2.MTC Y TLJALV2.INI. Estos son los ficheros que necesitaremos para que MPLAB pueda usar el compilador de JALv2. Lo primero será editar el fichero JALV2.MTC añadiendo al final las siguientes líneas, que permitirán que se invoque de forma correcta al compilador:

[20]
Description=Compile to object file
Switch=" "
Data=0
ObjectSwitch=Switch
Hidden=1

También tendremos que editar el fichero TLJALV2.INI para que no se use el fichero .COD que genera JALv2, ya que de momento no los genera de forma correcta, haciendo que los programas no funcionen. En lugar de usar el fichero .COD se usará el .HEX que si se genera bien. Solo hay que poner un ; (punto y coma) delante de la siguiente línea:

;Debug=COD

Con esto los ficheros ya estarán correctos, ahora solo habría que copiarlos en "C:\Archivos de programa\Microchip\MPLAB IDE\Core\MTC Suites" aunque falta añadir unas cuantas claves al registro de Windows para que MPLAB tenga todos los datos, para ello basta con pegar el siguiente código en un fichero al que le pongamos extensión .reg y ejecutarlo:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microchip\MPLAB IDE\Legacy Language Suites\{60FEA08C-E969-42cb-AD92-0B9E6CA68CCE}]
@="TLJALV2.INI"

[HKEY_LOCAL_MACHINE\SOFTWARE\Microchip\MPLAB IDE\Legacy Language Suites\{60FEA08C-E969-42cb-AD92-0B9E6CA68CCE}\Tools]

[HKEY_LOCAL_MACHINE\SOFTWARE\Microchip\MPLAB IDE\Legacy Language Suites\{60FEA08C-E969-42cb-AD92-0B9E6CA68CCE}\Tools\{08E50A89-91FD-48a7-9D47-64388B39A460}]
@="JALV2.MTC"

[HKEY_LOCAL_MACHINE\SOFTWARE\Microchip\MPLAB IDE\Legacy Language Suites\{60FEA08C-E969-42cb-AD92-0B9E6CA68CCE}\Tools\{08E50A89-91FD-48a7-9D47-64388B39A460}\{457E53D2-7129-47b9-B32D-FCA5A03C9145}]

[HKEY_LOCAL_MACHINE\SOFTWARE\Microchip\MPLAB IDE\Legacy Language Suites\{60FEA08C-E969-42cb-AD92-0B9E6CA68CCE}\{8803CD76-F3A8-40ae-A9B3-B920270D1E77}]

Tras esto simplemente abrimos el MPLAB y nos vamos a "Project->Set Language Tool Locations" seleccionamos "JALv2 Compiler->Executables->JALv2 Compiler" y pulsamos en Browse para elegir el ejecutable llamado jalv2.exe o jalv2d.exe.

Tras esto ya podremos crear proyectos usando JALv2 dentro de MPLAB. No hay que olvidar que si estamos usando jallib o incluso para poder hacer un include de las definiciones de los microcontrolades, deberemos de usar el argumento "-s ruta/a/librerias", esto se hace  añadiendo desde el mismo sitio la ruta al directorio con las librerías.

También he creado un fichero con todo lo necesario.
Espero que sea de ayuda.