Cree aplicaciones STM32 con Eclipse, GCC y STM32Cube

Si ha llegado a esta página, probablemente ya sepa que he cubierto este tema en el pasado. Mostré en una serie de tres publicaciones cómo configurar con éxito una cadena de herramientas completa de Eclipse / GCC para desarrollar aplicaciones para la placa de desarrollo STM32Nucleo-F4. Desde entonces, muchas personas me han informado de comentarios positivos sobre ese tutorial. Pero, algunos de ellos tuvieron serios problemas para que esas instrucciones funcionaran para otras familias de STM32 (F0, F1, etc.). Esto fue causado principalmente por el complemento de Eclipse de ARM de GNU, o más bien por las plantillas incluidas en el plug-in. Cuando se crea un nuevo proyecto utilizando el asistente de complementos, se utiliza una plantilla según la familia de procesadores. Desafortunadamente, el autor del complemento ha actualizado solo la plantilla para la familia STM32-F4 a la estructura HAL STM32Cube-F4 más reciente de ST (que todavía es compatible solo con IDE comercial …..), dejando las otras plantillas aún basadas en el Biblioteca estándar de periféricos anterior, que ya no es compatible con la herramienta ST y STM32CubeMX utilizada en mi tutorial. Esto hace que mis instrucciones sean incorrectas para familias de procesadores diferentes de STM32-F4. 

En esta publicación, le mostraré cómo configurar desde cero un proyecto de Eclipse para desarrollar aplicaciones para la plataforma STM32 utilizando la última versión del marco STM32Cube-Fx (la última versión disponible en el momento de la redacción es 1.6 para F4). Desafortunadamente, en este momento puedo probar estas instrucciones solo en un procesador STM32-F4, pero voy a comprar otras placas Nucleo para hacer pruebas. En este artículo no explicaré de nuevo todos los pasos necesarios para instalar Eclipse y GCC en su computadora. Si aún no ha instalado la cadena de herramientas base, puede comenzar a leer esta publicación  y detenerse en el párrafo ” Crear un proyecto de prueba “. Cuando esté listo, puede volver aquí de nuevo y continuar la lectura.

Antes de comenzar a crear nuestro nuevo proyecto de prueba, me gustaría decir algo sobre por qué usar Eclipse / GCC como una cadena de herramientas para desarrollar el firmware STM32. Porque esta es una pregunta muy común de los novatos.

¿Por qué elegir Eclipse / GCC como cadena de herramientas para STM32?

Esta es una pregunta muy común: ¿cuál es la mejor cadena de herramientas para desarrollar aplicaciones para STM32? Lamentablemente, la pregunta no es fácil de responder. Probablemente la mejor respuesta es que depende de la aplicación. En primer lugar, la audiencia debe dividirse entre profesionales y aficionados. La empresa prefiere utilizar IDE comerciales con tarifas anuales que permiten recibir soporte técnico. Tiene que darse cuenta de que en tiempo comercial significa dinero y, a veces, el IDE comercial puede reducir la curva de aprendizaje (especialmente si consideramos que ST da soporte explícito a estos entornos). Sin embargo, creo que incluso las empresas (especialmente si son organizaciones pequeñas) pueden tener grandes ventajas en el uso de una cadena de herramientas de código abierto.

En mi opinión, estas son las ventajas más importantes en el uso de una cadena de herramientas Eclipse / GCC para el desarrollo integrado con MCU STM32:

  • Se basa en GCC : GCC es probablemente el mejor compilador del mundo y ofrece excelentes resultados incluso con procesadores basados ​​en ARM. Actualmente, ARM es la arquitectura más extendida (gracias a la difusión de sistemas integrados en los últimos años), y muchos fabricantes de hardware y software utilizan GCC como herramienta fundamental para su plataforma.
  • Es multiplataforma : si tiene una PC con Windows, la última Mac sexy o un servidor Linux, podrá desarrollar, compilar y cargar con éxito el firmware en su placa de desarrollo sin ninguna diferencia. Hoy este no es un aspecto secundario.
  • Difusión de Eclipse : muchos IDE comerciales para STM32 (como TrueSTUDIO y otros) también se basan en Eclipse, que se convierte en una especie de estándar. Hay muchos complementos útiles para Eclipse que puede descargar con un solo clic. Y es un producto que evoluciona día a día.
  • Es Open Source : ok. Estoy de acuerdo. Para esas piezas gigantes de software, es muy difícil tratar de entender sus componentes internos y modificar el código, especialmente si usted es un ingeniero de hardware comprometido con los transistores y la administración de interrupciones. Pero si te metes en problemas con tu herramienta, es más simple tratar de entender qué funciona mal con una herramienta de código abierto que con una herramienta cerrada.
  • Comunidad grande y en crecimiento : estas herramientas tienen ahora una gran comunidad internacional, que continuamente desarrolla nuevas funciones y corrige errores. Encontrarás un montón de ejemplos y publicaciones de blog como esta, que pueden ayudarte durante tu trabajo. Además, muchas empresas, que han adoptado este software, contribuyen económicamente al desarrollo principal. Esto garantiza que el software no desaparecerá de repente.
  • Es gratis : sí. Coloqué esto como el último punto, pero no es el menos importante. Un IDE comercial puede costar una fortuna para una pequeña empresa o un aficionado. Y la disponibilidad de la herramienta gratuita es una de las ventajas clave de la plataforma STM32.

De acuerdo. Ahora podemos empezar a hacer cosas serias.

Resumen de todo el proceso.

Antes de comenzar a describir en profundidad el procedimiento para generar un firmware completamente funcional para nuestra placa, resumiré los pasos.

  • Primero generamos un esqueleto vacío para los procesadores ARM Cortex-M;
  • Luego pondremos en el lugar correcto toda la biblioteca HAL desarrollada por ST;
  • Luego configuramos algunas macros de proyectos y archivos de inicio del ensamblador;
  • Finalmente agregamos una muestra principal para probar si todo va bien.

Como veremos, todo el proceso consiste en arrastrar y soltar archivos del paquete STM32Cube al proyecto Eclipse. Nada más que esto.

Suposiciones y requisitos

En este tutorial asumiré que tienes:

  • Una completa cadena de herramientas Eclipse / GCC ARM con los complementos necesarios como se describe en esta publicación . Asumiré que toda la cadena de herramientas está instalada en C: \ STM32Toolchain o ~ / STM32Toolchain si tiene un sistema similar a UNIX.
  • El marco STM32Cube-F4 de ST ya se descargó y extrajo (si su placa está basada en otra familia de STM32, descargue el paquete correspondiente de STM32Cube, estoy casi seguro de que las instrucciones son perfectamente compatibles).
  • Una placa STM32Nucleo-F401RE (como dije antes, organice las instrucciones para su Nucleo si es diferente). Creo que también es sencillo organizar este procedimiento para otras placas, como el descubrimiento de STM32 más extendido.

Crear un proyecto vacío

El primer paso es crear un proyecto de esqueleto donde colocaremos la biblioteca HAL de ST. Entonces, inicie Eclipse y vaya a  Archivo-> Nuevo-> Proyecto C y seleccione “Hello World ARM Cortex-M C / C ++ project. Puede elegir el nombre del proyecto que desee (elegí” test1 “). Haga clic en” Siguiente ” .

Pantalla 2015-06-04 al 08.11.57
Pantalla 2015-06-04 al 08.14.12
Captura de pantalla 2015-06-04 en 08.24.02

En el siguiente paso tienes que configurar tu procesador. Para un STM32-F4, debe elegir el núcleo Cortex-M4, mientras que para un STM32-F4, debe elegir Cortex-M3. El reloj, el tamaño del flash y los parámetros de la RAM dependen de su Nucleo MCU. Para Nucleo-F401RE puede usar los mismos valores que se muestran en la siguiente imagen. Configure las otras opciones como se muestra a continuación .En el siguiente paso, deje todos los parámetros sin cambios, excepto el último: Nombre CMSIS del proveedor . Cámbielo de DEVICE a stm32f4xx si tiene una tarjeta basada en STM32F4, o stm32f1xx para las tarjetas F1, y así sucesivamente.Haga clic en ” Siguiente “. Puedes dejar los parámetros por defecto en los siguientes pasos. El paso final es sobre la cadena de herramientas de GCC. Puedes usar estos valores:

nombre de la cadena de herramientas:  herramientas GNU para procesadores integrados ARM (arm-none-eabi-gcc)
ruta de la cadena de herramientas: C: \ STM32Toolchain \ gnu-arm \ 4.8-2014q3 \ bin

Haga clic en ” Finalizar “.

Pantalla 2014-12-20 a las 22.16.28
Pantalla 2014-12-20 a 22.22.50

Ahora, si esta es la primera vez que te contactas con el IDE de Eclipse, podrías estar un poco aturdido por su interfaz. Eclipse es un IDE de múltiples ventanas, y las ventanas se pueden organizar en varios grupos con el nombre de  perspectiva , como se les llama en el gibberish de Eclipse. Está fuera de los objetivos de este artículo para explicar cómo funciona Eclipse. Le sugiero que juegue con los botones marcados en rojo en la siguiente imagen.Después de algunos clics, debe obtener una interfaz cercana a la de la siguiente imagen.

Importar STM32Cube-HAL en el proyecto Eclipse

De acuerdo. Ahora comienza la parte difícil. El proyecto generado por GNU ARM Plug-in para Eclipse es un esqueleto que contiene el estándar de interfaz de software de microcontroladores de Cortex (CMSIS) de ARM. CMSIS es una capa de abstracción de hardware independiente del proveedor para la serie de procesadores Cortex-M. Permite interfaces de software consistentes y simples para el procesador de periféricos de interfaz, sistemas operativos en tiempo real y middleware. Su objetivo es simplificar la reutilización del software y reducir el aprendizaje. Sin embargo, el paquete CMSIS no es suficiente para comenzar a programar con un chip STM32. También se requiere una capa de abstracción de hardware (HAL) específica del proveedor. Esto es lo que ST proporciona con su marco STM32Cube.

CMSIS-HAL

El diagrama anterior intenta explicar mejor todos los componentes involucrados en la generación de firmware final. CMSIS es el conjunto universal de funciones desarrolladas por ARM, y es común a todos los proveedores de Cortex-M (ST, ATMEL, etc.). ST HAL es la capa de abstracción de hardware desarrollada por ST para sus dispositivos específicos, y está relacionada con la familia STM32 (F0, F1, etc.). El dispositivo HAL es una especie de “conector” que permite a los dos subsistemas hablar entre sí. Es una vista realmente simplificada, pero esto es suficiente para comenzar a programar con esta arquitectura.

Echemos un vistazo al proyecto generado.

Pantalla 2015-06-04 al 09.01.15
  • Las carpetas / src  y / include contienen nuestra aplicación “principal”. El plug-in generó un archivo main.c. No utilizamos estos archivos, como veremos pronto, pero colocaremos un ejemplo “principal” en esa carpeta.
  • La carpeta / system esencialmente contiene el paquete ARM CMSIS.
  • / system / include / stm32f4xx y  / system / src / stm32f4xx son las carpetas donde colocaremos la HAL de STM32Cube.
  • / ldscripts contiene el script para el editor de enlaces GNU (ld). Estos scripts ordenan al vinculador que particione la memoria y realiza varias tareas al configurar interrupciones y rutinas de punto de entrada.

Ahora vamos a echar un vistazo a la subcarpeta cortexm .

Pantalla 2015-06-04 a las 14.00.20

Los archivos que he resaltado en azul en la imagen anterior son generados automáticamente por el complemento Eclipse de ARM de GNU. Son lo que se llama la parte HAL del dispositivo en el diagrama anterior. Estos archivos están sustancialmente vacíos y deben ser reemplazados por un código personalizado, ambos específicos para el único proveedor (ST en nuestro caso), ambos específicos para el MCU dado (STM32F401RE si tiene un Nucleo como el mío). Los vamos a eliminar.

Entonces, el primer paso es descargar la última versión de STM32Cube-F4 (o la correspondiente a su MCU) del sitio web de ST, descomprimirlo y colocarlo dentro de la carpeta C: \ STM32Toolchain . Una vez extraído, cambie el nombre de la carpeta de STM32Cube_FW_F4_V1.6.0  a  STM32Cube_FW_F4 .

A continuación, vaya al proyecto Eclipse y elimine los siguientes archivos:

  • /src/[main.c, Timer.c]
  • /include/Timer.h
  • /system/include/cmsis/[stm32f4xx.h,system_stm32f4xx.h]
  • /system/src/cmsis/[system_stm32f4xx.c,vectors_stm32f4xx.c]

Ahora tenemos que copiar HAL y otros archivos de STM32Cube al proyecto Eclipse.

  • HAL:  vaya dentro de la  carpeta STM32Cube_FW_F4 / Drivers / STM32F4xx_HAL_Driver / Srcy arrastre TODOS los archivos contenidos a la carpeta Eclipse / system / src / stm32f4xx . Eclipse le preguntará cómo copiar estos archivos en la carpeta del proyecto. Seleccione la entrada “Copiar”, como se muestra a continuación (use siempre esta opción): 

    Luego, vaya dentro de la  carpeta STM32Cube_FW_F4 / Drivers / STM32F4xx_HAL_Driver / Inc  y arrastre TODOS los archivos contenidos a la carpeta / sistema / include / stm32f4xx de Eclipse .
  • Dispositivo HAL: vaya dentro de la  carpeta STM32Cube_FW_F4 / Drivers / CMSIS / Device / ST / STM32F4xx / Include y arrastre TODOS los archivos contenidos a la carpeta  / system / include / cmsis de Eclipse . 
    Ahora necesitamos otros dos archivos. Si recuerdas, hasta ahora hemos eliminado dos archivos del proyecto generado:  system_stm32f4xx.c y vectors_stm32f4xx.c . Ahora necesitamos dos archivos que hagan el mismo trabajo (esencialmente, contienen las rutinas de inicio). El archivo  vectors_stm32f4xx.c  debe contener el código de inicio cuando se reinicia la MCU. Usaremos un archivo ensamblador provisto por ST. Vaya a  STM32Cube_FW_F4 / Drivers / CMSIS / Device / ST / STM32F4xx / Source / Templates / gcc Carpeta y arrastre el archivo correspondiente a su MCU dentro de la carpeta Eclipse  / system / src / cmsis . En nuestro caso, el archivo es  startup_stm32f401xe.s . Ahora, como Eclipse no puede administrar archivos que terminan con .s, tenemos que cambiar la extensión del archivo a. S (mayúscula). Así que el nombre de archivo final es startup_stm32f401xe.S . 
    Solo un paso más. Todavía necesitamos un  archivo system_stm32f4xx.c.  pero necesitamos uno específico para el MCU de nuestra junta. Vaya dentro de la  carpeta STM32Cube_FW_F4 / Drivers / CMSIS / Device / ST / STM32F4xx / Source / Templates  y arrastre el  archivo system_stm32f4xx.c dentro de la carpeta Eclipse  / system / src / cmsis .

De acuerdo. El marco está esencialmente configurado. Ahora necesitamos un proyecto de muestra que nos muestre que todo funciona bien. Tomaremos el ejemplo de LED parpadeante de ST.

Vaya dentro de la  carpeta STM32Toolchain / STM32Cube_FW_F4 / Projects / STM32F401RE-Nucleo / Example / GPIO / GPIO_IOToggle / Inc y copie TODO  el contenido dentro de la carpeta / incluido de Eclipse . Luego, vaya a  STM32Toolchain / STM32Cube_FW_F4 / Projects / STM32F401RE-Nucleo / Illustrations / GPIO / GPIO_IOToggle / src y copie solo los archivos  main.c y stm32f4xx_it.c dentro de la carpeta Eclipse / src . Finalmente, ST separó los pasos de configuración de la placa Nucleo específica en un paquete diferente, llamado Board Support Package (BSP). Vaya al interior del  STM32Cube_FW_F4 / Drivers / BSP / STM32F4xx-Nucleo y copie el  stm32f4xx_nucleo.c dentro delLa carpeta / src en Eclipse y el archivo  stm32f4xx_nucleo.h dentro de lacarpeta / include Eclipse.

Captura de pantalla 2015-06-04 en 15.18.26

Estamos casi al final de todo el procedimiento. Solo necesitamos configurar un par de cosas. Primero, debemos declarar qué MCU estamos utilizando al definir una macro global dentro de la configuración del proyecto. Para Nucleo-F401RE la macro es  STM32F401xE . Vaya dentro de las propiedades del proyecto (en el menú principal de Eclipse vaya a Proyecto-> Propiedades ), luego C / C ++ Construir-> Configuración . Haga clic en Configuración de herramientas y vaya a Compilador de ARM de Cross-> Preprocesador . Haga clic en el icono Agregar ( ) y agregue la macro  STM32F401xE .

Captura de pantalla 2015-06-04 en 15.16.21

Segundo, necesitamos configurar cómo se mapea la aplicación en la memoria de MCU. Este trabajo se realiza mediante el editor de enlaces (ld), que utiliza los tres archivos .ld dentro de la carpeta / ldscripts de Eclipse. El archivo que nos interesa es mem.ld , y debemos cambiar la dirección de origen de FLASH de  0x00000000 a  0x08000000 , como se muestra a continuación:

123…  FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 512K…

¿De dónde viene este número? No es un número mágico. Es simplemente la dirección donde se mapea el flash MCU interno en todos los microcontroladores STM32, como se puede ver en la siguiente imagen extraída de la hoja de datos de MCU.

Captura de pantalla 06-2457191 en 21.59.45

Terminado. Ahora puedes compilar el proyecto yendo a Proyecto-> Construir todo .

¿Que sigue?

Si es completamente nuevo en el proceso de desarrollo de Eclipse / GCC para STM32, debe volver a esta publicación y continuar con la lectura del párrafo ” Vamos a compilar el proyecto de prueba “. Debe SKIP la lectura del párrafo ” Adaptar el código de prueba a la placa Nucleo “, ya que el código que hemos utilizado aquí ya está diseñado para nuestro Nucleo. Una vez que haya terminado, puede comenzar a leer las partes 2 y 3 de esa serie completamente.

Deja un comentario

Tu dirección de correo electrónico no será publicada.