El desarrollo de STM32 código del microcontrolador en Linux (Parte 2 de 8, construyendo el compilador cruzado)

El primer post de esta serie cubre los pasos para generar y ejecutar código para el STM32. Este post va a cubrir cómo construir un compilador cruzado para el STM32.
Los pasos para construir un compilador cruzado son algo cubiertos aquí y aquí. En teoría, la construcción de un compilador cruzado es un proceso bastante sencillo:

1. Cruz compilar binutils, a hacer las cosas como que (ensamblador), ld (enlazador), nm (símbolos lista de objetos), etc
2. Cruz compilar gcc, que le da una C y C + + compilador.
3. Cruz compilar newlib, que le da un ambiente de libc, como mínimo para programar pulg

Sin embargo , hay una gran Gotcha. No todas las combinaciones de binutils, gcc, y el trabajo en conjunto newlib. Peor aún, no todas las combinaciones de ellos se basan en todos los entornos de desarrollo, que puede hacer esto algo de una experiencia frustrante. Por ejemplo, se sabe que binutils <2,24 no construye en máquinas con texinfo 5.x o posterior. Por lo tanto, en las máquinas modernas (como Fedora 19), que debe utilice binutils 2.24 o posteriores. Además, me pareció que la última newlib de escribir este artículo (2.1.0) no se basa en Fedora 19. Su kilometraje puede variar, y esto es casi seguro que cambie en el futuro, el mejor consejo que puedo dar es empezar con las últimas versiones de los paquetes y luego retroceder lentamente de los que fallan hasta que obtenga una combinación relativamente reciente que funciona. A los efectos de este artículo, que terminé usando binutils 2.24, 4.8.2 y gcc 2.0.0 newlib. Esta combinación se acumula muy bien en Fedora 19.
Ahora sobre los pasos necesarios para crear el entorno de compilación cruzada. Primero tenemos que hacer que se instalan seguro ciertas herramientas. Vamos a instalar las herramientas de desarrollo a través de yum:

  
 $  sudo yum install gcc crea bzip2 wget tar gmp-devel  /> 
  

Siguiente buscamos a las versiones pertinentes de los paquetes:

 
 $  mkdir ~ / cross-src /> 
 $  wget ftp://ftp.gnu.org/gnu/binutils/binutils-2.24.tar.gz 
 $  wget ftp://ftp.gnu.org/gnu/gcc/gcc-4.8 
 .2/gcc-4.8.2.tar.bz2 $  wget ftp://sources.redhat.com/pub/newlib/newlib-2.0.0.tar.gz 
  

Siguiente establecimos algunas variables de entorno. Esto no es estrictamente necesario, pero nos ayudará a reducir errores en los siguientes pasos:

 
 $  export TOPDIR = ~ / cross-src /> 
 PREFIJO $  export = ~ / opt / cross /> 
 $  export PATH = $  PREFIX / bin: $  PATH 
  

La variable de entorno TOPDIR es el directorio en el que las fuentes se almacenan. La variable de entorno TARGET es la arquitectura que queremos que nuestro compilador emita código. Para los chips de ARM, sin un sistema operativo (como el STM32), queremos armar Coincidir eabi. La variable de entorno PREFIJO es el lugar que queremos nuestras herramientas de compilación cruzada para acabar en, no dude en cambiar esto a algo más adecuado. La variable de entorno BUILDPROCS es el número de procesadores que podemos utilizar, vamos a utilizar todos ellos, mientras que la construcción para acelerar considerablemente el proceso de generación. Por último, hay que añadir la ubicación de los binarios de compilación cruzada en nuestro camino para que las últimas etapas de construcción pueden encontrarlo.
Ahora podemos empezar a construir. Primero tenemos que construir binutils:

 
 $  cd $  TOPDIR /> 
 $  mkdir build-binutils 
 $  cd acumulaciones binutils 
 $  .. / binutils-2.24/configure - target = $  OBJETIVO - prefix = $  PREFIX  
 - enable-interoperación - disable-nls 
 $  make -j $  BUILDPROCS /> 
  

Básicamente estamos deshaciendo binutils, haciendo una construcción fuera de árbol (recomendado), y luego instalarlo. Las banderas de configurar merecen alguna explicación. La opción - target dice binutils qué destino desea que las herramientas para construir para, es decir, qué tipo de código se emitirá por el código. En nuestro caso, queremos ARM sin sistema operativo. La opción - prefijo dice binutils que queremos que nuestras herramientas sean instalados a $ PREFIX. La opción - enable-funcionen conjuntamente indicador permite binutils que emiten una combinación de ARM y el código PULGAR, si usted no sabe lo que es eso, no te preocupes por eso, por ahora. Por último, la opción - disable-nls bandera dice binutils no construir archivos de traducción, lo que acelera la acumulación. Suponiendo que este paso fue muy bien en el equipo de desarrollo, debe haber un conjunto de herramientas en ~ / opt / cross / bin (o cualquiera que sea su directorio de salida de alto nivel es) llamado brazo Coincidir eabi-*. Si esto no funciona, entonces es posible que desee probar una versión más reciente o más antigua de binutils, no se puede avanzar más sin este trabajo. Chat con binutils construidas, ahora podemos pasar a gcc:

 
 $  cd $  TOPDIR /> 
 $  tar-xvf gcc-4.8.2.tar.bz2 /> 
 $  cd build-gcc 
 $  .. / gcc-4.8.2/configure - -target = $  OBJETIVO - prefix = $  PREFIX  
 - enable-interoperación - disable-nls - enable-languages ​​= "c, c + +"  
 - without-headers - con -newlib  
 - with-headers = $  TOPDIR/newlib-2.0.0/newlib/libc/include 
 $  make-j $  BUILDPROCS todo gcc /> 
  

Aquí estamos deshaciendo gcc y newlib (que se requiere para la construcción de gcc), haciendo una construcción de la parte inicial de gcc fuera del árbol, y luego instalarlo. Las banderas de configurar merecen alguna explicación. La opción - target dice GCC qué objetivo desea que las herramientas que emiten código. La opción - prefijo dice gcc que queremos que nuestras herramientas sean instalados a $ PREFIX. La opción - enable-funcionen conjuntamente permite gcc para emitir una combinación de ARM y el código PULGAR. El - disable-nls bandera dice gcc no construir archivos de traducción, lo que acelera la acumulación. Los - enable-languages ​​bandera le dice a gcc que los compiladores que queremos construir, en nuestro caso, los compiladores tanto la C y C + +. El - without-headers - with-newlib y - with-headers banderas dice gcc que no utilizar conectores internos, sino más bien utilizar newlib y los encabezados de newlib. Suponiendo que este paso ha finalizado correctamente, no debe haber un archivo llamado ~ / opt / cross / bin / brazo--ningunos eabi-gcc, que es el compilador inicial. Una vez más, si no funciona, entonces es posible que desee probar una versión más reciente o más antigua de gcc, no se puede avanzar más sin esto. Chat con el compilador inicial construido, ahora podemos construir newlib:

  
 $  cd $  TOPDIR /> 
 
 $  .. / newlib-2.0.0/configure - target = $  OBJETIVO - prefix = $  PREFIX  
 - enable-funcionen conjuntamente 
 $  make-j $  BUILDPROCS 
 $  make install 
  

Desde que hemos newlib ya sin envasar, nos saltamos ese paso. Aquí estamos haciendo una acumulación de newlib fuera del árbol, usando el compilador que hemos construido en el último paso. Las banderas de configure tienen el mismo significado que anteriormente. Chat con newlib construido, ahora podemos volver atrás y terminar la construcción de gcc (el último paso!):

$ cd $ TOPDIR / build-gcc /> $ make-j $ BUILDPROCS
$ make install


Esto termina la compilación gcc, y lo instala a $ PREFIX. Eso es todo! Ahora debe tener un directorio PREFIJO $ llena de herramientas y los encabezados útiles para construir código para ejecutarse en el STM32.
actualización 08 de enero 2014: Se ha actualizado el formato de modo que es más fácil de leer.