stm32 cube cmake vscode

Entorno de desarrollo STM32 con Visual Studio Code y CMake

Este tutorial explica los pasos para desarrollar y depurar eficazmente una aplicación STM32 en Visual Studio Code utilizando el generador de compilación CMake , la herramienta de compilación Ninja y el compilador GCC .

Cosas que aprenderás

• Cómo instalar y configurar todas las herramientas

• Cómo crear un nuevo proyecto STM32 con las herramientas STM32CubeMX o STM32CubeIDE

• Cómo instalar y configurar extensiones recomendadas para Visual Studio Code para facilitar el desarrollo

• Cómo configurar listas de CMake y ajustes preestablecidos de CMake

• Cómo generar un sistema de compilación para el compilador

• Cómo compilar el proyecto con GCC

• Cómo actualizar y depurar una aplicación en el objetivo STM32

Este tutorial utiliza el sistema operativo Windows . Se aplicará un procedimiento similar para los sistemas operativos Linux y MAC.

Instalación de herramientas

Actualización de agosto de 2024

El tutorial de instalación de herramientas lo ayudará a comprender las herramientas necesarias para trabajar con STM32 y, en general, es bueno para que los principiantes se pongan al día y comprendan correctamente los requisitos necesarios.

Desde hace algún tiempo, ST tiene una nueva herramienta de software STM32CubeCLT, que incluye las herramientas de compilación necesarias para vscode, incluye el sistema de compilación Ninja y el generador de compilación CMake . STM32CubeCLT (Herramientas de línea de comandos) es una forma sencilla y fácil de ponerse al día rápidamente con el desarrollo de vscode. También configurará automáticamente las variables de entorno de compilación ( Ruta en el caso de Windows), lo que le permitirá invocar ninja , cmake u otros comandos directamente desde la herramienta de línea de comandos.

Al instalar STM32CubeCLT , no obtendrá la herramienta gráfica STM32CubeIDE , ni obtendrá ninguna capacidad de herramienta de configuración de MCU, sino solo herramientas de línea de comandos para invocar la compilación y la depuración, normalmente desde vscode . Aún necesitará instalar vscode por separado y las extensiones necesarias.

STM32CubeIDE

El primer paso es instalar STM32CubeIDE, que se utilizará para iniciar fácilmente un nuevo proyecto STM32 y viene con la herramienta STM32CubeMX integrada, lo que nos permite la configuración gráfica.

STM32CubeIDE también proporciona las herramientas necesarias más adelante para el desarrollo de VSCode

• Compilador ARM ninguno eabi GCC

• ST-LINK GDBServer para depuración

• Herramienta STM32CubeProgrammer para descarga de código y controladores ST-Link respectivos

• Carpeta con archivos STM32 SVD

• Controladores para ST-Link

Configuración de ruta ambiental

Se deben agregar 3 rutas a la configuración ambiental desde la instalación de STM32CubeIDE, una ruta para cada una de las herramientas mencionadas anteriormente. En el caso de mi computadora, usando STM32CubeIDE 1.8 (actualizado a través de eclipse, por lo tanto, mi ruta de instalación real todavía muestra la versión 1.0.2 ), las rutas se definen como:

• Compilador GCC: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346toolsbin

• Servidor ST-Link GDB: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221toolsbin

• CLI del programador STM32Cube: c:STSTM32CubeIDE_1.0.2STM32CubeIDEpluginscom.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430toolsbin

Sus rutas pueden diferir en los números de versión

Verifique la configuración de ruta correcta, ejecute:

arm-none-eabi-gcc --version
STM32_Programmer_CLI --version
ST-LINK_gdbserver --version

Eso debería producir un resultado similar al de la siguiente imagen.

Chacer

Este paso no es necesario si ha instalado las herramientas de compilación con STM32CubeCLT

Descargue e instale CMake.

El asistente de instalación le pedirá que agregue CMake a las rutas ambientales. Seleccione la opción o agregue la carpeta bin de la carpeta de instalación de CMake a la ruta ambiental.

ninja

Este paso no es necesario si ha instalado las herramientas de compilación con STM32CubeCLT

Descargue el sistema de compilación Ninja desde la página de lanzamientos de Github. Viene como ejecutable portátil, sin necesidad de instalar nada. Sin embargo debe ser visible a nivel del entorno, como todas las herramientas anteriores.

Verifique la instalación de CMake y Ninja , ejecute:

cmake --version
ninja --version

La salida será algo similar a

Código de estudio visual

Descargue e instale VSCode. Una vez instalada y abierta, la ventana será similar a la siguiente.

Extensiones de código de Visual Studio

Visual Studio Code es un editor de texto liviano con capacidad de ampliarlo mediante extensiones.

Lista de extensiones útiles para el desarrollo STM32 usando CMake:

• ms-vscode.cpptools : resaltado de sintaxis y otras funciones principales para el desarrollo de C/C++

• ms-vscode.cmake-tools : herramientas principales de CMake, herramienta generadora de sistemas de compilación

• twxs.cmake : resaltado de color CMake

• marus25.cortex-debug : extensión de depuración Cortex-M, obligatoria para la depuración STM32 desde VSCode

• dan-c-underwood.arm : resaltador de sintaxis de ensamblaje ARM

• zixuanwang.linkerscript : resaltador de sintaxis del script GCC Linker

Puede instalarlos copiando los siguientes comandos en la ventana de terminal interna de VSCode.

code --install-extension ms-vscode.cpptools
code --install-extension ms-vscode.cmake-tools
code --install-extension twxs.cmake
code --install-extension marus25.cortex-debug
code --install-extension dan-c-underwood.arm
code --install-extension zixuanwang.linkerscript

Vaya a Terminal -> Nueva Terminal para abrir una nueva ventana de terminal

Una forma alternativa es utilizar la GUI de búsqueda de extensiones e instalarla manualmente desde allí.

Herramientas instaladas - punto de control

En este punto, todas las herramientas están instaladas correctamente: está en el camino correcto hacia el éxito.

Creación de nuevo proyecto

El requisito fundamental para seguir adelante es tener un proyecto funcional que se convertirá a CMake y se desarrollará en VSCode . Para ello, lo guiaré a través de la creación sencilla de nuevos proyectos utilizando las herramientas de software STM32CubeMX o STM32CubeIDE .

Puedes saltarte esta parte si ya tienes tu proyecto en el que trabajar.

Utilicé la herramienta STM32CubeIDE y la placa STM32H735G-DK para esta demostración.

Abra STM32CubeIDE y comience un nuevo proyecto

Seleccione STM32 MCU: seleccioné STM32H735IG que se usa en la placa STM32H735G-DK

Seleccione el nombre y la ruta del proyecto, luego cree el proyecto y espere a que se abra la vista Pinout

Nuestra tarea es tener un proyecto simple que alterne los LED. Los LED están conectados a PC2 y PC3 respectivamente, activos en nivel BAJO. Los pines se pueden configurar en modo push-pull de salida o drenaje abierto

Establezca pines como salidas con etiquetas opcionales como LED1 y LED2 respectivamente

Si está utilizando STM32CubeMX , vaya al Administrador de proyectos , establezca el nombre del proyecto y asegúrese de que STM32CubeIDE esté seleccionado como Toolchain .

Vaya a configuración avanzada y seleccione LL como controladores para el código generado

Estamos utilizando controladores LL por simplicidad en este tutorial.

Vuelva a generar el proyecto presionando el botón rojo o guardando el proyecto con el acceso directo CTRL + S

El proyecto ahora está (re)generado. Los archivos resaltados en amarillo son fuentes para construir. El azul es el script del enlazador.

Eso es todo para la primera ejecución, estamos listos para compilar. Presione CTRL + B o haga clic en el ícono de martillo para comenzar. STM32CubeIDE compilará el proyecto, debería ver algo similar a la imagen a continuación. Ahora está listo para actualizar la memoria flash de la MCU y comenzar la depuración.

Este es el final de la primera parte, donde creamos con éxito nuestro proyecto. En este punto, consideramos que el proyecto está listo para transferirse al sistema de compilación basado en CMake.

Puede continuar su desarrollo con STM32CubeIDE en el futuro, agregar nuevas fuentes, modificar código, compilar, actualizar el binario y depurar directamente el microcontrolador. Este es el estudio de desarrollo STM32 preferido, desarrollado y mantenido por STMicroelectronics.

Configuración de CMake

Se espera que se haya creado el proyecto a desarrollar en VSCode. Avanzaremos con el compilador GCC, pero también se podrían utilizar otros.

Con el lanzamiento de Visual Studio Code, muchos desarrolladores utilizan la herramienta para muchos lenguajes de programación y, afortunadamente, también pueden desarrollar aplicaciones STM32 con una sola herramienta. Si usted es uno de los desarrolladores a los que les gusta VSCode, la forma más elegante de avanzar es transferir el proyecto basado en STM32CubeIDE a CMake , desarrollar código en VSCode y compilar con el sistema de compilación Ninja usando el compilador GCC. Es rápido y ligero.

El desarrollo en VSCode es para usuarios intermedios o experimentados. Sugiero a todos los principiantes de STM32 que se queden con la cadena de herramientas de desarrollo STM32CubeIDE . Será muy fácil avanzar y llegar al tema de VSCode más adelante.

Prepare el archivo CMakeLists.txt

Cada aplicación basada en CMake requiere el archivo CMakeLists.txt en el directorio raíz , que describe el proyecto y proporciona información de entrada para la generación del sistema de compilación.

El archivo raíz CMakeLists.txt a veces se denomina archivo CMake de nivel superior

Cosas esenciales descritas en el archivo CMakeLists.txt :

• Información de la cadena de herramientas, como la configuración de GCC con indicadores de compilación

• Nombre del proyecto

• Archivos fuente para compilar con archivos compiladores, C, C++ o ensambladores

• Lista de rutas de inclusión para que el compilador encuentre funciones, defina, ... ( -I )

• Ruta del script del vinculador

• La compilación define, o a veces se llama definición del preprocesador ( -D )

• Cortex-Mxx y configuraciones de punto flotante para la generación de conjuntos de instrucciones

Abra VSCode en la carpeta raíz del proyecto

Visual Studio Code se ha instalado y se utilizará como editor de archivos adicional.

Encuentre la ruta de su proyecto generado y abra la carpeta con VSCode:

• Opción 1: vaya a la carpeta con el explorador, luego haga clic derecho y seleccione Open in Code .

• Opción 2: alternativamente, abra VScode como una nueva solución vacía y agregue una carpeta manualmente. Utilice File -> Open Folder... para abrir la carpeta

• Opción 3: vaya a la carpeta con cmd o la herramienta powershell y ejecute code .

El resultado final debería ser similar al siguiente.

Información de la cadena de herramientas

CMake debe conocer la cadena de herramientas que nos gustaría utilizar para compilar finalmente el proyecto. Como la misma cadena de herramientas generalmente se reutiliza en diferentes proyectos, se recomienda crear esta parte en un archivo separado para facilitar su reutilización. Estas son configuraciones genéricas del compilador y no están directamente vinculadas a los proyectos en sí.

Se puede utilizar un archivo .cmake simple y luego reutilizarlo entre sus diversos proyectos. Estoy usando el nombre cmake/gcc-arm-none-eabi.cmake para este tutorial y a continuación se muestra su ejemplo:

 set(CMAKE_SYSTEM_NAME Generic)set(CMAKE_SYSTEM_PROCESSOR arm)# Algunas configuraciones predeterminadas de GCC# arm-none-eabi- deben ser parte del entorno de rutaset(TOOLCHAIN_PREFIX arm-none-eabi-)set(FLAGS "-fdata-sections -ffunction-sections - -specs=nano.specs -Wl,--gc-secciones")set(CPP_FLAGS "-fno-rtti -fno-exceptions -fno-threadsafe-statics")# Definir la configuración del compiladorset(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc ${FLAGS})set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++ $ {BANDERAS} ${CPP_FLAGS})set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)set(CMAKE_SIZE ${TOOLCHAIN_PREFIX}tamaño)set(CMAKE_EXECUTABLE_SUFFIX_ASM ".elf")set(CMAKE_EXECUTABLE_SUFFIX_C ".elf")set(CMAKE_EXECUTABLE_SUFFIX_CXX ".elf")conjunto(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

Cree un archivo en la carpeta cmake/ del directorio raíz del proyecto.

Si el complemento resaltador de CMake está instalado, VSCode resaltará muy bien los comandos de CMake por usted

La configuración de la cadena de herramientas está completa. Puede cerrar el archivo libremente y pasar al siguiente paso.

Crear el archivo principal CMakeLists.txt

Necesitamos crear CMakeLists.txt principal, también llamado archivo raíz CMake.

Asegúrese de nombrarlo CMakeLists.txt con los caracteres correctos en mayúsculas y minúsculas.

Preparé un archivo de plantilla simple para usted, que puede reutilizar para todos sus proyectos en el futuro. Sólo necesitarás cambiar cosas como el nombre del proyecto, los archivos fuente, incluir rutas, etc.

 cmake_minimum_required(VERSIÓN 3.22)# Configurar la configuración del compiladorset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Tipo de compilación: " ${CMAKE_BUILD_TYPE})## Configuración del proyecto principal#project(nombre-de-su-proyecto)enable_language(C CXX ASM)## Indicadores de MCU central, CPU, El conjunto de instrucciones y el número de configuración de FPU deben configurarse correctamente para su conjunto de MCU (CPU_PARAMETERS
    -mthumb# Esto necesita atención para configurarlo correctamente para MCU-mcpu=cortex-m7 usado
    -mfpu=fpv5-d16
    -mfloat-abi=duro
)# Establecer script del vinculadorset(linker_script_SRC ${PROJ_PATH}/path-to-linker-script.ld)set(EXECUTABLE ${CMAKE_PROJECT_NAME})## Lista de archivos fuente para compilar#set(sources_SRCS# Coloque aquí sus archivos fuente, uno en cada línea, en relación con la ubicación del archivo CMakeLists.txt)## Incluir directorios#set(include_path_DIRS# Coloque aquí su inclusión directorios, uno en cada línea, relativo a la ubicación del archivo CMakeLists.txt)## Definición de símbolos#set(symbols_SYMB# Coloque aquí sus símbolos (definidos por el preprocesador), uno en cada línea# Encapsúlelos con comillas dobles por motivos de seguridad)# Archivos ejecutablesadd_executable (${EXECUTABLE} ${sources_SRCS})# Incluir pathstarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Proyecto symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Opciones del compiladortarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpedante
    -Wno-unused-parameter# Configuración de depuración completa-Og -g3 -ggdb
)# Opciones del vinculadortarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Soporte de formato flotante STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--grupo final
    -Wl,--uso-de-memoria-de-impresión
)# Ejecutar post-compilación para imprimir sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la salida a hexadecimal y binarioadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir a archivo bin -> agregar verificación condicional?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binario $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Los archivos fuente son los mismos que en el proyecto STM32CubeIDE . Puede consultar la imagen anterior con las fuentes resaltadas en color amarillo.

Los símbolos y las rutas de inclusión se pueden encontrar en STM32CubeIDE en la configuración del proyecto. 2 imágenes a continuación muestran cómo es en el caso del proyecto de demostración.

La configuración de Cortex-Mxx necesita una atención especial, especialmente con la configuración de punto flotante. Para STM32H735xx , la configuración debe establecerse como se muestra a continuación.

 establecer(CPU_PARAMETERS
    -mpulgar
    -mcpu=cortex-m7 # Establecer CPU Cortex-M-mfpu=fpv5-d16 # Establecer tipo de coma flotante-mfloat-abi=hard # Modo ABI de hardware)

La regla general para la configuración sería la siguiente en la tabla

Familia STM32	-mcpu	-mfpu	-mfloat-abi
STM32F0	cortex-m0	Not used	soft
STM32F1	cortex-m3	Not used	soft
STM32F2	cortex-m3	Not used	soft
STM32F3	cortex-m4	fpv4-sp-d16	hard
STM32F4	cortex-m4	fpv4-sp-d16	hard
STM32F7SP	cortex-m7	fpv5-sp-d16	hard
STM32F7 DP	cortex-m7	fpv5-d16	hard
STM32G0	cortex-m0plus	Not used	soft
STM32C0	cortex-m0plus	Not used	soft
STM32G4	cortex-m4	fpv4-sp-d16	hard
STM32H5	cortex-m33	fpv5-sp-d16	hard
STM32H7	cortex-m7	fpv5-d16	hard
STM32L0	cortex-m0plus	Not used	soft
STM32L1	cortex-m3	Not used	soft
STM32L4	cortex-m4	fpv4-sp-d16	hard
STM32L5	cortex-m33	fpv5-sp-d16	hard
STM32U0	cortex-m0plus	Not used	soft
STM32U5	cortex-m33	fpv5-sp-d16	hard
STM32WB	cortex-m4	fpv4-sp-d16	hard
STM32WBA	cortex-m33	fpv5-sp-d16	hard
STM32WL CM4	cortex-m4	Not used	soft
STM32WL CM0	cortex-m0plus	Not used	soft

Esta tabla está sujeta a posibles errores y no se ha probado con el compilador GCC para todas las líneas. Para STM32F7 , vaya al sitio oficial de STM32F7xx y verifique si su dispositivo tiene FPU de precisión simple o doble, luego aplique la configuración correspondiente. La lista de productos no es exhaustiva.

Archivo CMakeLists.txt final después de que se establezcan los archivos fuente, las rutas incluidas, la configuración principal de MCU y las definiciones:

 cmake_minimum_required(VERSIÓN 3.22)# Configurar la configuración del compiladorset(CMAKE_C_STANDARD 11)set(CMAKE_C_STANDARD_REQUIRED ON)set(CMAKE_C_EXTENSIONS ON)set(CMAKE_CXX_STANDARD 20)set(CMAKE_CXX_STANDARD_REQUIRED ON)set(CMAKE_CXX_EXTENSIONS ON)set(PROJ_PATH ${CMAKE_CURRENT_SOURCE_DIR})message("Tipo de compilación: " ${CMAKE_BUILD_TYPE})## Configuración del proyecto principal#project(STM32H735G-DK-LED) # Modifiedenable_language(C CXX ASM)## Indicadores de MCU central, CPU , conjunto de instrucciones y número de configuración de FPU deben configurarse correctamente para su MCU#conjunto(CPU_PARAMETERS
    -mthumb# Esto necesita atención para configurarlo correctamente para MCU usado-mcpu=cortex-m7 # Modified-mfpu=fpv5-d16 # Modified-mfloat-abi=hard # Modified)# Establecer scriptset del vinculador(linker_script_SRC ${PROJ_PATH}/STM32H735IGKX_FLASH. ld) # Conjunto modificado (EJECUTABLE ${CMAKE_PROJECT_NAME})## Lista de archivos fuente para compilar#set(sources_SRCS # Modificado${PROJ_PATH}/Core/Src/main.c${PROJ_PATH}/Core/Src/stm32h7xx_it.c${PROJ_PATH}/Core/Src/syscalls.c${PROJ_PATH}/Core/Src/sysmem.c$ { PROJ_PATH}/Core/Src/system_stm32h7xx.c${PROJ_PATH}/Core/Startup/startup_stm32h735igkx.s${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm3 2h7xx_ll_exti.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_gpio.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_l l_pwr.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_rcc.c${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_utils.c
)## Incluir directorios#set(include_path_DIRS # Modificado${PROJ_PATH}/Core/Inc${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Inc${PROJ_PATH}/Drivers/CMSIS/Device/ST/STM32H7xx/Include${PROJ_PATH}/ Controladores/CMSIS/Incluir
)## Definición de símbolos#set(symbols_SYMB # Modificado"DEBUG""STM32H735xx""USE_FULL_LL_DRIVER""HSE_VALUE=25000000")# Archivos ejecutablesadd_executable(${EXECUTABLE} ${sources_SRCS})# Incluir rutastarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})# Proyecto symbolstarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})# Opciones del compiladortarget_compile_options(${EXECUTABLE} PRIVATE${CPU_PARAMETERS}-Wall
    -Wextra
    -Wpedante
    -Wno-unused-parameter# Configuración de depuración completa-Og -g3 -ggdb
)# Opciones del vinculadortarget_link_options(${EXECUTABLE} PRIVATE-T${linker_script_SRC}${CPU_PARAMETERS}-Wl,-Map=${CMAKE_PROJECT_NAME}.map
    --specs=nosys.specs
    -u _printf_float # Soporte de formato flotante STDIO-Wl,--start-group
    -lc
    -lm
    -lstdc++
    -lsupc++
    -Wl,--grupo final
    -Wl,--uso-de-memoria-de-impresión
)# Ejecutar post-compilación para imprimir sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la salida a hexadecimal y binarioadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir a archivo bin -> agregar verificación condicional?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binario $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

En VSCode, bien resaltado, se ve así

Cree un archivo CMakePresets.json preestablecido

CMakePresets.json es un archivo especial, disponible desde CMake 3.18 y proporciona una definición para la configuración del usuario, similar a la configuración de depuración y lanzamiento conocida en eclipse. Tener este archivo permite al desarrollador cambiar rápidamente entre el modo de depuración y el modo de lanzamiento , o incluso entre el gestor de arranque y la aplicación principal , que es un caso de uso común en aplicaciones integradas.

Este tutorial no se centrará en los detalles sobre el archivo, sino que aquí está el archivo de plantilla proporcionado.

El archivo describe:

• Ruta al directorio de compilación para cada configuración de compilación

• Tipo de compilación predeterminado para cada configuración ( depuración , lanzamiento , ...)

• Ruta al descriptor de la cadena de herramientas .cmake

Se configuran 4 ajustes preestablecidos en la plantilla para cada una de las configuraciones predeterminadas de CMake

 {"versión": 3,"configurePresets": [
        {"name": "default","hidden": true,"generator": "Ninja","binaryDir": "${sourceDir}/build/${presetName}","toolchainFile": "${sourceDir} /cmake/gcc-arm-none-eabi.cmake","cacheVariables": {"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"}
        },
        {"name": "Depurar","hereda": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Depurar"}
        },
        {"name": "RelWithDebInfo","inherits": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "RelWithDebInfo"}
        },
        {"name": "Versión","hereda": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "Versión"}
        },
        {"name": "MinSizeRel","hereda": "default","cacheVariables": {"CMAKE_BUILD_TYPE": "MinSizeRel"}
        }
    ]
}

El archivo siempre actualizado está disponible en templates/CMakePresets.json

Ejecutar comandos de CMake

Hemos configurado CMake con información del proyecto y ahora estamos listos para ejecutar los comandos de CMake.

VSCode viene con el complemento CMake Tools , una gran ayuda para los comandos de CMake. Cuando está instalado, hay varias opciones disponibles en la parte inferior de la ventana activa de VSCode

Como puede ver, no hay ningún ajuste preestablecido de configuración seleccionado.

Si no ve dicha información, presione CTRl + ALT + P y ejecute CMake: Quick Start .

El siguiente paso es seleccionar el preset actual. Haga clic en No Configure Preset Selected para abrir una ventana en la parte superior y seleccione su preset . Seleccioné depurar por el bien de este tutorial.

Cuando se selecciona, el texto cambiará a la etiqueta preestablecida seleccionada.

Ahora que el ajuste preestablecido está activo, cada vez que el usuario modifique el archivo CMakeLists.txt , gracias a la extensión CMake-Tools , VSCode invocará automáticamente el comando de generación de compilación para aplicar nuevos cambios.

construir proyecto

Nuestro proyecto está listo para construir y vincular. A menos que el paso de generación de compilación de CMake falle, deberíamos tener el directorio de compilación listo para invocar el sistema de compilación ninja .

El siguiente paso es presionar el botón Construir , como se indica con el rectángulo verde. CMake ejecutará comandos:

• Ejecute el generador de compilación para el ajuste preestablecido seleccionado

• Realmente construye código con Ninja

Si se construye bien, el paso final en el resultado es imprimir el uso de la memoria con diferentes secciones.

Como resultado, obtuvimos algunos resultados en el directorio build/<presetname>/ :

• Archivo project-name.elf con información ejecutable completa

• project-name.hex archivo HEX

• project-name.bin archivo BIN

• archivo de mapa project-name.map

En la configuración predeterminada, los archivos .hex y .bin no se generan ni se muestra el uso de memoria . Nuestro archivo CMakeLists.txt preparado incluye opciones POST_BUILD para ejecutar comandos adicionales después de una compilación exitosa. El código ya está en su archivo CMakeLists.txt , por lo que no es necesario hacer nada, solo observar.

Ejecuta el comando para:

• Imprimir tamaño utilizado de cada región + consumo de memoria ejecutable final

• Generar archivo .hex desde ejecutable

• Generar archivo .bin desde ejecutable

 # Ejecute la compilación posterior para imprimir sizeadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_SIZE} $<TARGET_FILE:${EXECUTABLE}>
)# Convertir la salida a hexadecimal y binarioadd_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.hex
)# Convertir a archivo bin -> agregar verificación condicional?add_custom_command(TARGET ${EXECUTABLE} POST_BUILDCOMMAND ${CMAKE_OBJCOPY} -O binario $<TARGET_FILE:${EXECUTABLE}> ${EXECUTABLE}.bin
)

Para deshabilitar la generación de archivos .bin , simplemente elimine la línea POST_BUILD para .bin y regenere los comandos del sistema de compilación CMake. La generación de archivos .bin puede tener un efecto negativo cuando la memoria se divide entre memorias flash internas y externas. Puede generar archivos muy grandes ( >= 2GB ) con muchos ceros no utilizados.

Hay una lista de comandos útiles a tener en cuenta durante el desarrollo del proyecto:

• cambios de compilación

• Proyecto limpio

• Proyecto de reconstrucción, con limpieza primero.

• proyecto flash

Es fácil olvidar la sintaxis completa, mejor creemos el archivo .vscode/tasks.json con la lista de comandos, para una ejecución rápida:

 { "versión": "2.0.0", "tareas": [
        {"type": "cppbuild","label": "Crear proyecto","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "- j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"],"group": {"kind": "build"," isDefault": verdadero}
        },
        {"type": "shell","label": "Reconstruir proyecto","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "--clean-first", "-v", "-j", "8"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": ["$gcc"] ,
        },
        {"type": "shell","label": "Limpiar proyecto","command": "cmake","args": ["--build", "${command:cmake.buildDirectory}", "- -target", "clean"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg: Proyecto Flash (SWD)","command": "STM32_Programmer_CLI","args": ["--connect","port=swd","- -download", "${command:cmake.launchTargetPath}","-hardRst"],"options": {"cwd": "${workspaceFolder}"},"problemMatcher": []
        },
        {"type": "shell","label": "CubeProg: proyecto Flash con número de serie definido (SWD); primero debe configurar el número de serie",