单片机开发IDE环境如KeilMDK，虽然操作简单, para facilitar la depuración. Pero el estilo de edición de código es muy anticuado y los símbolos chinos ilegibles siguen siendo comunes. Y ahora, el popular editor vscode es muy bueno, gratuito y bastante liviano, la experiencia de desarrollo de código es muy buena y parece cómoda. Clion IDE tiene una mejor experiencia, pero no es gratis y tiene un gran tamaño. Stm32cubeIDE es fácil de generar y configurar plantillas de proyecto, pero la finalización automática sigue siendo una lástima. En resumen, cada uno tiene sus propias ventajas y desventajas.

prefacio

Aquí hay una introducción a Vscode para construir un IDE para desarrollar y depurar STM32, y compartirlo con amigos que lo necesiten.

Al igual que el proyecto basado en Clion de Zhihui Jun, todos son proyectos basados en Cmake. De hecho, no se limita a si el chip es STM32 o RISC-V. Use la depuración en línea de openocd).

Aunque también hay un complemento EIDE en Vscode, personalmente creo que es un poco engorroso y Cmake es más general. No es muy bueno desarrollar STM32 con Vscode. Espero que todos puedan desarrollar sistemas integrados con gracia. La imagen se cita de "Configuración de CLion para el desarrollo STM32 [Elegant Embedded Development]" de Zhihui Jun

【Nota】

Para el MCU RISC-V actualmente popular, siempre que haya una cadena de herramientas de compilación cruzada, vscode también se puede usar para la configuración y el desarrollo. La computadora host del depurador admitida oficialmente por RISC-V es openocd. openocd es la computadora host de depuración de código abierto más poderosa (nadie) en la superficie, que admite varios objetivos (ARM (serie M, A), FPGA, RISC-V, etc.) y varios depuradores (Jlink, CMSIS-DAP, FTDI, etc.), admite interfaces JTAG y SWD.

Preparación ambiental

Entorno de software

STM32CubeMX (no es necesario, la ventaja es que puede ayudarlo a configurar rápidamente, si hay una plantilla de proyecto, puede ignorarla)
VScode (instalar complementos relevantes cmakeTools, cortexDebug)
MinGW64 (cadena de herramientas gcc en entorno Windows)
OpenOCD (o jlinkGdbServer también funciona)
gcc-arm-none-eabi (cadena de herramientas de edición cruzada gcc de arm, que debe agregarse a la variable de entorno después de la instalación)

Enlaces a los recursos utilizados

Descargue archivos ejecutables directamente desde el sitio web oficial de ST

MinGW 【https://sourceforge.net/projects/mingw-w64/files/】
Cmake 【Descargar | CHacer】
STM32CubeMX【STM32CubeMX - Generador de código de inicialización STM32Cube - STMicroelectronics】
arm-none-eabi-gcc 【https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads】
OpenOCD 【https://gnutoolchains.com/arm-eabi/openocd/】

Los programas CMake, MinGW64, arm-none-eabi-gcc y OpenOCD anteriores son necesarios. La ruta de instalación está preferiblemente libre de caracteres chinos y espacios. Configure las variables de entorno para asegurarse de que estas líneas de comandos puedan ejecutarse normalmente bajo cmd.

La velocidad de descarga de sitios web extranjeros puede ser lenta, aquí está la dirección de la cadena de herramientas del disco de red Baidu que uso

链接：https://pan.baidu.com/s/1NCQykQ57Xh6PFe28TU_GGw?pwd=goyj 
提取码：goyj 
--来自百度网盘超级会员V5的分享

Después de configurar la variable de entorno, después de reiniciar para que la variable de entorno surta efecto, puede usar la siguiente declaración para probar en la línea de comando:

gcc -v
brazo-ninguno-eabi-gcc -v

cmake --version
Si hay salida de información, se instala.

Si no quiere preocuparse por el proyecto de construcción y quiere experimentarlo lo antes posible, puede usar mi plantilla directamente.

Se adjunta el enlace de descarga del código fuente del proyecto, que se puede abrir directamente con vscode:

https://download.csdn.net/download/qq8864/8785579

Instalación del complemento Vscode

Vscode necesita descargar e instalar los siguientes complementos, solo se necesita la línea roja en la primera captura de pantalla:

contenido del script cmake

Las reglas de organización y compilación de cmake se basan en el archivo CMakeLists.txt.Si está familiarizado con CMake, debería encontrarlo muy conveniente y poderoso. Está bien si no está familiarizado con él. Básicamente, no necesita modificar nada. Solo necesita saber cómo agregar la ruta del directorio del código fuente e incluir la carpeta en este archivo. Este archivo rara vez se modifica.

#THIS FILE IS AUTO GENERATED FROM THE TEMPLATE! DO NOT CHANGE!
set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_VERSION 1)
cmake_minimum_required(VERSION 3.20)

# specify cross compilers and tools
set(CMAKE_C_COMPILER arm-none-eabi-gcc)
set(CMAKE_CXX_COMPILER arm-none-eabi-g++)
set(CMAKE_ASM_COMPILER arm-none-eabi-gcc)
set(CMAKE_AR arm-none-eabi-ar)
set(CMAKE_OBJCOPY arm-none-eabi-objcopy)
set(CMAKE_OBJDUMP arm-none-eabi-objdump)
set(SIZE arm-none-eabi-size)
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

# project settings
project(vscodeSTM32Demo  C CXX ASM)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_C_STANDARD 11)

#Uncomment for hardware floating point
#add_compile_definitions(ARM_MATH_CM4;ARM_MATH_MATRIX_CHECK;ARM_MATH_ROUNDING)
#add_compile_options(-mfloat-abi=hard -mfpu=fpv4-sp-d16)
#add_link_options(-mfloat-abi=hard -mfpu=fpv4-sp-d16)

#Uncomment for software floating point
#add_compile_options(-mfloat-abi=soft)

add_compile_options(-mcpu=cortex-m3 -mthumb -mthumb-interwork)
add_compile_options(-ffunction-sections -fdata-sections -fno-common -fmessage-length=0)

# uncomment to mitigate c++17 absolute addresses warnings
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-register")

if ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
    message(STATUS "Maximum optimization for speed")
    add_compile_options(-Ofast)
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
    message(STATUS "Maximum optimization for speed, debug info included")
    add_compile_options(-Ofast -g)
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
    message(STATUS "Maximum optimization for size")
    add_compile_options(-Os)
else ()
    message(STATUS "Minimal optimization, debug info included")
    add_compile_options(-Og -g)
endif ()

add_definitions(-DUSE_HAL_DRIVER -DSTM32F103xB -DUSE_STDPERIPH_DRIVER -DSTM32F10X_HD)

include_directories(./STM32F10x_FWLib/inc ./include)
file(GLOB_RECURSE SOURCES "startup/*.*" STM32F10x_FWLib/src/*.c "./source/*.c")

set(LINKER_SCRIPT ${CMAKE_SOURCE_DIR}/STM32F103C8Tx_FLASH.ld)

add_link_options(-Wl,-gc-sections,--print-memory-usage,-Map=${PROJECT_BINARY_DIR}/${PROJECT_NAME}.map)
add_link_options(-mcpu=cortex-m3 -mthumb -mthumb-interwork)
add_link_options(-T ${LINKER_SCRIPT})

add_link_options(-specs=nano.specs -specs=nosys.specs -u _printf_float)

add_executable(${PROJECT_NAME}.elf ${SOURCES} ${LINKER_SCRIPT})

set(HEX_FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.hex)
set(BIN_FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.bin)

add_custom_command(TARGET ${PROJECT_NAME}.elf POST_BUILD
        COMMAND ${CMAKE_OBJCOPY} -Oihex $<TARGET_FILE:${PROJECT_NAME}.elf> ${HEX_FILE}
        COMMAND ${CMAKE_OBJCOPY} -Obinary $<TARGET_FILE:${PROJECT_NAME}.elf> ${BIN_FILE}
        COMMENT "Building ${HEX_FILE}
Building ${BIN_FILE}")

Configuración de ingeniería

En realidad, STM32CubeMX no es necesario, solo necesitamos configurar un script CMake y un archivo *.s de inicio, que STM32CubeMX puede generar, y la misma placa también se puede copiar y usar directamente. Entre ellos, el archivo STM32F103C8Tx_FLASH.ld es un archivo de script de enlace, que es muy importante. Los diferentes tipos de películas son diferentes. Le dice al compilador el código ejecutable compilado relevante, las variables de memoria, los vectores de interrupción y qué área de almacenamiento (.text, .ubicación y disposición de las secciones rodata, .data, .bss, etc. en RAM y ROM).

cómo utilizar

El código de ingeniería del proyecto inicial se puede generar mediante la configuración de STM32Cubmx, se puede copiar desde otros lugares o puede crear manualmente el directorio usted mismo. El archivo de ensamblado startup_stm32f103xb.s y el archivo de secuencia de comandos del vinculador son necesarios. El archivo CMakeLists.txt también es necesario. Puede escribirlo usted mismo o usar una plantilla escrita. Hay archivos de plantilla listos para usar en este artículo. Con estos, no importa si usa la biblioteca HAL o la biblioteca estándar, no importa qué biblioteca use.

Con la premisa de que el entorno de software anterior y los complementos están instalados, puede abrir directamente la carpeta de origen del proyecto (la carpeta donde se encuentra CMakeLists.txt) con Vscode. La configuración del proyecto de cmake se reconocerá automáticamente y los elementos relacionados se mostrarán en la parte inferior. Como se muestra en la línea roja en la siguiente figura:

Seleccione el botón del icono de configuración en la barra de estado inferior para cambiar la cadena de herramientas, como se muestra en la siguiente figura:

Registro del proceso de compilación

[main] Configuring project: vscodeSTM32Demo 
[proc] Executing command: "D:\Program Files\CMake\bin\cmake.EXE" --no-warn-unused-cli -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE -DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo -DCMAKE_C_COMPILER:FILEPATH=C:\tools\arm-gcc\bin\arm-none-eabi-gcc.exe -DCMAKE_CXX_COMPILER:FILEPATH=C:\tools\arm-gcc\bin\arm-none-eabi-g++.exe -SD:/Users/Administrator/Desktop/test3/vscodeSTM32Demo -Bd:/Users/Administrator/Desktop/test3/vscodeSTM32Demo/build -G Ninja
[cmake] Not searching for unused variables given on the command line.
[cmake] -- Maximum optimization for speed, debug info included
[cmake] -- Configuring done
[cmake] -- Generating done
[cmake] -- Build files have been written to: D:/Users/Administrator/Desktop/test3/vscodeSTM32Demo/build


[main] Building folder: vscodeSTM32Demo 
[build] Starting build
[proc] Executing command: "D:\Program Files\CMake\bin\cmake.EXE" --build d:/Users/Administrator/Desktop/test3/vscodeSTM32Demo/build --config RelWithDebInfo --target all --
[build] [14/29   3% :: 0.202] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/source/main.c.obj
[build] [15/29   6% :: 0.222] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/core_cm3.c.obj
[build] [16/29  10% :: 0.265] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/source/printf_uart.c.obj
[build] [17/29  13% :: 0.297] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/stm32f10x_bkp.c.obj
[build] [18/29  17% :: 0.310] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/misc.c.obj
[build] [19/29  20% :: 0.325] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/stm32f10x_cec.c.obj
[build] [20/29  24% :: 0.339] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/stm32f10x_dbgmcu.c.obj
[build] [21/29  27% :: 0.355] Building C object CMakeFiles/vscodeSTM32Demo.elf.dir/STM32F10x_FWLib/src/stm32f10x_dac.c.obj

Captura de pantalla de compilación:

Programa de grabación y depuración en línea

Antes de grabar, debe agregar el archivo de configuración del emulador. El siguiente es el archivo de grabación de DAP-link . Puede modificarlo de acuerdo con los parámetros del descargador disponible, y guardarlo en el formato de xxxlink.cfg , y ponerlo en el directorio del proyecto config en la carpeta de

# choose st-link/j-link/dap-link etc.
source [find interface/cmsis-dap.cfg]
transport select swd
# 0x10000 = 64K Flash Size
# 0x80000 = 512K Flash Size
set FLASH_SIZE 0x80000
source [find target/stm32f1x.cfg]
# download speed = 10MHz
adapter speed 10000
reset_config srst_only
#reset_config none

Cree una nueva carpeta en el directorio raíz del proyecto configy cree un nuevo archivo de configuración en él daplink.cfg(porque aquí uso DapLink como emulador), el contenido del archivo es el siguiente:

# choose st-link/j-link/dap-link etc.
adapter driver cmsis-dap
transport select swd

# 0x10000 = 64K Flash Size
set FLASH_SIZE 0x20000

source [find target/stm32f1x.cfg]

# download speed = 10MHz
adapter speed 10000

Si usa ST-Link:

# choose st-link/j-link/dap-link etc.
#adapter driver cmsis-dap
#transport select swd
source [find interface/stlink.cfg]
transport select hla_swd
source [find target/stm32f1x.cfg]
# download speed = 10MHz
adapter speed 10000

Las primeras dos líneas establecen el tipo y la interfaz del emulador, y las siguientes líneas especifican el tamaño de Flash , el tipo de chip , la velocidad de descarga , etc.

Si no sabe cómo configurar su chip, puede consultar una serie de archivos de configuración que vienen con OpenOCD, la ruta se encuentra en el share\openocd\scriptsdirectorio de instalación de OpenOCD.

reset_config srst_onlyNo agregue esta oración en el archivo de configuración , hará que la descarga falle. Esta oración es para indicarle al sistema que se reinicie y eliminarla no afectará la descarga.

Programa de programación en serie ISP

Si no hay necesidad de depurar la emulación en el circuito, este es el final aquí. El archivo hexadecimal generado puede usar directamente la herramienta de puerto serie para descargar el programa. El software de la herramienta FlyMcu es una herramienta para la programación del puerto serie ISP con chip STM32, gratuita y relativamente fácil de usar, fácil de usar y conveniente. Hay un requisito previo para la descarga de una tecla utilizando el puerto serie, es decir, su placa de circuito debe tener un circuito de conmutación de puerto serie RS, entre los cuales DTR y RTS son necesarios. El propósito es prepararse para la descarga de una tecla, y configure el nivel BOOT0 a nivel alto.Para guiar el chip STM al programa de programación del puerto serie, el principio es controlar el cambio del pin de arranque a través de DTR y RTS para que el chip ingrese al modo de actualización de arranque.

Dirección de descarga de herramientas: Red de programación en línea MCU: www.mcuisp.com Red de programación en línea MCU

Descargador de emuladores

Ingrese el comando openocd -f interface/stlink-v2.cfg -f target/stm32f4x.cfg -c "program build/VSCodeF4.hex verificar reset exit" en la terminal para descargar el programa.

Para implementar la depuración como Keil en VSCode, debe configurar el archivo de depuración y hacer clic en el botón de depuración a la izquierda. Elija crear un archivo launch.json. Seleccione C++(GDB/LLDB) y luego seleccione la configuración predeterminada.

Seleccione Depuración de Cortex: OpenOcd

Edite launch.json en la carpeta .vscode en el directorio raíz del proyecto y agregue el siguiente contenido (configuración de configFiles y svdFile), la ruta ejecutable debe modificarse a la ruta real para generar el archivo elf:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "cwd": "${workspaceRoot}",
            "executable": "./bin/executable.elf",
            "name": "Debug with OpenOCD",
            "request": "launch",
            "type": "cortex-debug",
            "servertype": "openocd",
            "configFiles": [
                "stlink-v2.cfg",
                "stm32f4x.cfg"
            ],
            "searchDir": [],
            "runToEntryPoint": "main",
            "showDevDebugOutput": "none",
            "svdFile": "./STM32F40x.svd"

        }

    ]
}

Acerca de OpenOCD

Como se puede ver en los pasos del IDE anteriores, OpenOCD es una herramienta que conecta gdb y el depurador de hardware, y está disponible en Linux, MacOS y Windows. OpenOCD admite una gran cantidad de depuradores de hardware, como los depuradores stlink y jlink comúnmente utilizados por stm32. OpenOCD es un software de depuración de código abierto que se ejecuta en una PC. Fue iniciado originalmente por Dominic Rath cuando aún estaba en la universidad (2005). OpenOCD está diseñado para proporcionar capacidades de depuración, programación del sistema y escaneo de límites para dispositivos integrados.

El archivo SVD es un archivo de registro de un solo chip. Solo agregando este archivo puede ver el valor del registro durante la depuración. El cambio del valor del registro se puede ver rompiendo el punto en el programa para ver el cambio del registro. valor. El archivo svd del microcontrolador stm32 se puede encontrar en la ruta de instalación del paquete de chips de keil. (Solo se puede encontrar después de instalar el paquete Keil and Chip)

Ejecute la interfaz de depuración:

Este es el final, bienvenido a comunicarse si tiene alguna pregunta. ¡Finalmente, puede usar vscode felizmente para desarrollar, para ayudarlo a desarrollar felizmente!