Ejecución de FreeRTOS en un STM32Nucleo con una cadena de herramientas GCC / Eclipse gratuita

Usar un micro como el STM32F4, capaz de correr hasta 160Mhz, con 512Kb de flash y aproximadamente 100k de RAM, sin usar un sistema operativo es una tontería. Aunque es perfectamente posible utilizar algunas formas de programación cooperativa para ejecutar actividades de firmware, esto no es conveniente, especialmente cuando se trata de eventos de bajo nivel relacionados con el hardware (por ejemplo, manejo de interrupciones) y aspectos relacionados con la sincronización. Mientras su firmware comience a crecer, necesitará construcciones para sincronizar las actividades del firmware, como colas o semáforos. Además, especialmente cuando se trata de dispositivos de baja potencia, un giro ocupado ( mientras que(algunas condiciones); ) no es la mejor solución si tiene que luchar con mAh.

FreeRTOS es probablemente el sistema operativo en tiempo real más difundido en el mundo integrado. Existen varios RTOS, tanto gratuitos como comerciales, pero probablemente FreeRTOS sea el que haya alcanzado la máxima difusión. Creo que hay otras alternativas válidas para FreeRTOS, pero no hay duda de que es la más popular con un soporte bueno y oficial de varios proveedores de MCU. ST también proporciona un soporte completo para este sistema operativo, y se distribuye como componente de middleware dentro del marco STCubeF4. Además, la herramienta STCubeMX puede generar todo el código necesario para inicializarlo.

Muchos de ustedes me pidieron un tutorial sobre cómo usar FreeRTOS en la placa de desarrollo STM32Nucleo utilizando una cadena de herramientas gratuita GCC / Eclipse. Como veremos, una vez que se define una cadena de herramientas completa, no es una tarea compleja comenzar a programar con FreeRTOS. Desarrollaremos una sencilla aplicación de led parpadeante, el “Hola mundo” de todos los proyectos de hardware, y usaremos este proyecto para mostrar cómo configurar FreeRTOS y cómo usar tareas y semáforos.

Requisitos del sistema

En cuanto a los tutoriales anteriores, no le mostraré todos los pasos necesarios para configurar toda la cadena de herramientas de GCC / Eclipse, pero asumiré:

  • 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 framework STM32Cube-F4 de ST ya se descargó y extrajo dentro del directorio ~ / STM32Toolchain / STM32Cube_FW_F4 (si su placa está basada en otra familia STM32, descargue el paquete correspondiente de STM32Cube, estoy casi seguro de que las instrucciones son perfectamente compatibles).
  • La última versión de FreeRTOS (se puede descargar desde aquí ; he probado con éxito la versión 8.2.1) extraída dentro del directorio ~ / STM32Toolchain / FreeRTOSV8.
  • Una placa STM32Nucleo-F401RE (como dije antes, organice las instrucciones para su Nucleo si es diferente).

Primer paso: crear un proyecto esqueleto

En el primer paso de este tutorial, crearemos un proyecto de esqueleto. Una vez creados, importaremos dentro del proyecto todos los archivos relacionados con FreeRTOS. El procedimiento es casi el mismo que se describe en esta publicación , pero lo describiré nuevamente para aclarar algunos pasos. Luego, usaremos CubeMX para generar los archivos de configuración que necesitamos para configurar FreeRTOS y el archivo main.c.

Entonces, vamos a crear un proyecto básico donde colocaremos la biblioteca HAL de las fuentes ST y FreeRTOS. Inicie Eclipse y vaya a  Archivo-> Nuevo-> Proyecto C y seleccione el proyecto “Hello World ARM Cortex-M C / C ++. Puede elegir el nombre del proyecto que desee (yo elegí ” stm32-nucleof4-freertos “). Haga clic en ” Siguiente “. 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 .

Pantalla 2015-06-04 al 08.14.12

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.

Captura de pantalla 2015-06-04 en 08.24.02

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 .

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. 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. En este tutorial no entraré en detalles de la estructura del proyecto. Si necesita saber más acerca de lo que ha generado el complemento ARM de GNU, consulte esta otra publicación .

Ahora, entra en el proyecto Eclipse y borra 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”. Luego, ingrese a la carpeta STM32Cube_FW_F4 / Drivers / STM32F4xx_HAL_Driver / Inc  y arrastre TODOS los archivos contenidos a la carpeta / system / include / stm32f4xx de Eclipse . Cuando haya terminado, vaya a la carpeta Eclipse / system / src / srm32f4xx y elimine el archivo  stm32f4xx_hal_msp_template.c (usaremos el generado por la herramienta CubeMX más adelante).
  • 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 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 placa. 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. La HAL está configurada en su mayoría. Para completar esta parte, tenemos que establecer un par de cosas. Primero, debemos establecer una macro global del proyecto que defina nuestro tipo de MCU. Esta macro es necesaria para compilar la HAL correctamente. Para Nucleo-F401RE, la macro es  STM32F401xE  ( organízala para tu tablero si es diferente). 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

Segundo paso: importar fuentes de FreeRTOS en el proyecto.

El siguiente paso principal es importar los archivos fuente de FreeRTOS dentro del proyecto. ST ya distribuye con el marco STM32Cube un completo árbol de fuentes de FreeRTOS. Sin embargo, no es la última versión disponible. Así que usaremos la versión oficial como se indica en el párrafo de requisitosdel sistema .

Antes de comenzar a importar archivos, necesitamos dos carpetas de Eclipse en nuestro proyecto. Cree una carpeta llamada FreeRTOS dentro de la carpeta / system / include / y otra dentro de la carpeta / system / src . Ahora:

  • vaya dentro de la  carpeta STM32Toolchain / FreeRTOSV8.2.1 / FreeRTOS / Source / include y arrastre TODOS los archivos contenidos a la carpeta / system / include / FreeRTOS de Eclipse  ;
  • vaya a la  carpeta STM32Toolchain / FreeRTOSV8.2.1 / FreeRTOS / Source  y arrastre TODOS los archivos “.c” a la carpeta Eclipse  / system / src / FreeRTOS ;

Ahora necesitamos otro par de cosas. FreeRTOS está diseñado para ser independiente del hardware específico. Es capaz de ejecutarse en 35 arquitecturas diferentes y varios compiladores, tanto comerciales como gratuitos. La parte relacionada con el hardware y el compilador específicos se encuentra dentro de la  carpeta STM32Toolchain / FreeRTOSV8.2.1 / FreeRTOS / Source / portable  . Asi que:

  • vaya dentro de la 
    carpeta STM32Toolchain / FreeRTOSV8.2.1 / FreeRTOS / Source / portable / GCC / ARM_CM4F  y arrastre el archivo port.c dentro de la carpeta Eclipse  / system / src / FreeRTOS  y el archivo portmacro.h dentro de la carpeta Eclipse  / system / include / FreeRTOS  .

Todavía necesitamos otro archivo de la distribución de FreeRTOS. FreeRTOS ofrece varios esquemas de administración de pilas que varían en complejidad y características. Queda fuera del alcance de este artículo explicar las diferencias entre los 5 esquemas de pila proporcionados en FreeRTOS. Lo que es importante para nosotros ahora, es que necesitamos importar uno de estos esquemas dentro de nuestro proyecto Eclipse. Asi que:

  • vaya dentro de la  carpeta STM32Toolchain / FreeRTOSV8.2.1 / FreeRTOS / Source / portable / MemMang  y arrastre el archivo heap_2.c dentro de la carpeta Eclipse  / system / src / FreeRTOS (necesitamos al menos heap_2.c porque usaremos  osThreadTerminate () para terminar una tarea).

De acuerdo. FreeRTOS está casi configurado. Sólo necesitamos otras dos cosas. En primer lugar, debemos informar a Eclipse sobre los archivos de inclusión de FreeRTOS. Esto significa que tenemos que agregar la carpeta / system / include / FreeRTOS dentro de las rutas de acceso del proyecto. Vaya dentro de las propiedades del proyecto, luego C / C ++ Build-> Settings . Haga clic en Configuración de herramientasy luego en Compilador ARM C cruzado -> Incluye y agregue la carpeta como se muestra a continuación.

Pantalla 2015-06-17 a 09.09.58

Deja un comentario

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