{"id":20435028,"url":"https://github.com/majerle/stm32-cube-cmake-vscode","last_synced_at":"2025-04-04T08:09:52.366Z","repository":{"id":39753786,"uuid":"445617122","full_name":"MaJerle/stm32-cube-cmake-vscode","owner":"MaJerle","description":"STM32, VSCode and CMake detailed tutorial","archived":false,"fork":false,"pushed_at":"2024-08-12T06:27:38.000Z","size":44669,"stargazers_count":609,"open_issues_count":1,"forks_count":61,"subscribers_count":25,"default_branch":"main","last_synced_at":"2025-03-28T07:07:41.370Z","etag":null,"topics":["cmake","cortex-debug","cpptools","ctools","ninja","stm32","stm32cubeide","stm32cubemx","vscode"],"latest_commit_sha":null,"homepage":"","language":"C","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/MaJerle.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"custom":["paypal.me/tilz0R"]}},"created_at":"2022-01-07T18:30:29.000Z","updated_at":"2025-03-27T02:59:06.000Z","dependencies_parsed_at":"2024-11-15T08:42:25.672Z","dependency_job_id":null,"html_url":"https://github.com/MaJerle/stm32-cube-cmake-vscode","commit_stats":null,"previous_names":[],"tags_count":3,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/MaJerle%2Fstm32-cube-cmake-vscode","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/MaJerle%2Fstm32-cube-cmake-vscode/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/MaJerle%2Fstm32-cube-cmake-vscode/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/MaJerle%2Fstm32-cube-cmake-vscode/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/MaJerle","download_url":"https://codeload.github.com/MaJerle/stm32-cube-cmake-vscode/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247142074,"owners_count":20890653,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cmake","cortex-debug","cpptools","ctools","ninja","stm32","stm32cubeide","stm32cubemx","vscode"],"created_at":"2024-11-15T08:30:25.822Z","updated_at":"2025-04-04T08:09:52.343Z","avatar_url":"https://github.com/MaJerle.png","language":"C","funding_links":["paypal.me/tilz0R"],"categories":[],"sub_categories":[],"readme":"# STM32 development environment with Visual Studio Code and CMake\n\nThis tutorial explains steps to effectively develop and debug STM32 application in *Visual Studio Code* using *CMake* build generator, *Ninja* build tool and *GCC* compiler.\n\nThings you will learn\n\n- How to install and setup all tools\n- How to create new STM32 project with STM32CubeMX or STM32CubeIDE tools\n- How to install and setup recommended extensions for *Visual Studio Code* for easier development\n- How to setup CMake lists and CMake presets\n- How to generate build system for compiler\n- How to compile the project with GCC\n- How to flash and debug application to the STM32 target\n\n\u003e This tutorial is using *Windows* operating system. Similar procedure will apply for Linux and MAC operating system.\n\n# Tools installation\n\n## August 2024 update\n\nThe tools installation tutorial will help you to understand the necessary tools required to work with STM32 and is generally good for beginners to get up to speed and correctly understand necessary requirements.\n\nSince some time, ST has a new [STM32CubeCLT](https://www.st.com/en/development-tools/stm32cubeclt.html) software tool, that includes the build tools necessary for vscode, includes *Ninja* build system and *CMake* build generator. STM32CubeCLT (Command Line Tools) is a simple and easy way to quickly get up to speed for vscode development. It will also setup your build environment variables (*Path* in case of Windows) automatically, allowing you to invoke *ninja*, *cmake* or other commands directly from command line tool.\n\n\u003e By installing the *STM32CubeCLT*, you won't get *STM32CubeIDE* graphical tool, nor you will get any MCU configuration tool capability, rather just command line tools to invoke build and debug, normally from within *vscode*. You will still need to separately install vscode and necessary extensions.\n\n## STM32CubeIDE\n\nFirst step is to install [STM32CubeIDE](https://www.st.com/en/development-tools/stm32cubeide.html), that will be used to easily start new *STM32* project and it comes with integrated *STM32CubeMX* tool - allowing us graphical configuration.\n\nSTM32CubeIDE also provides necessary tools needed later for *VSCode* development\n\n- ARM none eabi GCC compiler\n- ST-LINK GDBServer for debugging\n- STM32CubeProgrammer tool for code downloading and respective ST-Link drivers\n- Folder with STM32 SVD files\n- Drivers for ST-Link\n\n**Environmental path setup**\n\n`3` paths should be added to environmental settings from STM32CubeIDE installation, one path for each of above-mentioned tools.\nIn case of my computer, using STM32CubeIDE 1.8 (updated through eclipse, hence my actual installation path is still showing version `1.0.2`) paths are defined as:\n\n- GCC compiler: `c:\\ST\\STM32CubeIDE_1.0.2\\STM32CubeIDE\\plugins\\com.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346\\tools\\bin\\`\n- ST-Link GDB server: `c:\\ST\\STM32CubeIDE_1.0.2\\STM32CubeIDE\\plugins\\com.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221\\tools\\bin\\`\n- STM32Cube Programmer CLI: `c:\\ST\\STM32CubeIDE_1.0.2\\STM32CubeIDE\\plugins\\com.st.stm32cube.ide.mcu.externaltools.cubeprogrammer.win32_2.0.100.202110141430\\tools\\bin\\`\n\n\u003e Your paths may differ at version numbers\n\nVerify correct path setup, run:\n```\narm-none-eabi-gcc --version\nSTM32_Programmer_CLI --version\nST-LINK_gdbserver --version\n```\n\nThat should produce output similar to the picture below\n\n![STM32CubeIDE environment test](docs/images/gcc-prog-gdb-version-test.png)\n\n## CMake\n\n\u003e This step is not necessary if you have installed the build tools with *STM32CubeCLT*\n\nDownload and install [CMake](https://cmake.org/).\n\nInstallation wizard will ask you to add CMake to environmental paths. Select the option or add `bin` folder of CMake installation folder to environmental path.\n\n## Ninja\n\n\u003e This step is not necessary if you have installed the build tools with *STM32CubeCLT*\n\nDownload [Ninja build system](https://github.com/ninja-build/ninja/releases) from Github releases page.\nIt comes as portable executable, without need to install anything.\nHowever it must be visible at environment level, like all previous tools.\n\nVerify *CMake* and *Ninja* installation, run:\n```\ncmake --version\nninja --version\n```\n\nOutput shall be something similar to\n\n![CMake and Ninja verification](docs/images/cmake-ninja-version-test.png)\n\n## Visual Studio Code\n\nDownload and install [VSCode](https://code.visualstudio.com/). Once installed and opened, window will look similar to the one below.\n![Visual Studio Code first time](docs/images/vscode-first-time.png)\n\n## Visual Studio Code extensions\n\n*Visual Studio Code* is lightweight text editor with capability to enlarge it using extensions.\n\nList of useful extensions for STM32 development using CMake:\n\n- `ms-vscode.cpptools`: Syntax highlighting and other core features for C/C++ development\n- `ms-vscode.cmake-tools`: CMake core tools, build system generator tool\n- `twxs.cmake`: CMake color highlighting\n- `marus25.cortex-debug`: Cortex-M debugging extension, mandatory for STM32 debug from VSCode\n- `dan-c-underwood.arm`: ARM Assembly syntax highlighter\n- `zixuanwang.linkerscript`: GCC Linker script syntax highlighter\n\nYou can install them by copying below commands in VSCode's internal terminal window.\n\n```\ncode --install-extension ms-vscode.cpptools\ncode --install-extension ms-vscode.cmake-tools\ncode --install-extension twxs.cmake\ncode --install-extension marus25.cortex-debug\ncode --install-extension dan-c-underwood.arm\ncode --install-extension zixuanwang.linkerscript\n```\n\n\u003e Go to *Terminal -\u003e New Terminal* to open new terminal window\n\n![VSCode installed plugins](docs/images/vscode-plugins-installed.png)\n\nAlternative way is to use *Extension search GUI* and manually install from there.\n\n![VSCode installed plugins](docs/images/vscode-plugins-installed-preview.png)\n\n## Tools installed - checkpoint\n\nAt this point, all the tools are properly installed - you are on the right track towards success.\n\n# New project creation\n\nFundamental requirement to move forward is to have a working project that will be converted to *CMake* and developed in *VSCode*.\nFor this purpose, I will guide you through simple new project creation using *STM32CubeMX* or *STM32CubeIDE* software tools.\n\nYou can skip this part, if you already have your project to work on.\n\n\u003e I used *STM32CubeIDE* tool and  STM32H735G-DK board for this demo.\n\nOpen STM32CubeIDE and start new project\n![STM32CubeIDE - 1](docs/images/cubeide-1.png)\n\nSelect STM32 MCU - I selected *STM32H735IG* which is used on *STM32H735G-DK* board\n![STM32CubeIDE - 2](docs/images/cubeide-2.png)\n\nSelect project name and path, then create project and wait for *Pinout view* to open\n![STM32CubeIDE - 3](docs/images/cubeide-3.png)\n\nOur task is to have a simple project that will toggle leds. LEDs are connected to `PC2` and `PC3` respectively, active LOW. Pins can be configured in output push-pull or open-drain mode\n![STM32CubeIDE - 4 - 1](docs/images/cubeide-4-1.png)\n\nSet pins as outputs with optional labels as `LED1` and `LED2` respectively\n![STM32CubeIDE - 4](docs/images/cubeide-4.png)\n\nIf you are using `STM32CubeMX`, go to *Project manager*, set project name and be sure `STM32CubeIDE` is selected as `Toolchain`.\n![STM32CubeIDE - 5](docs/images/cubeide-5.png)\n\nGo to advanced settings and select `LL` as drivers for generated code\n![STM32CubeIDE - 6](docs/images/cubeide-6.png)\n\u003e We are using LL drivers for the sake of simplicity in this tutorial\n\nRe-generate the project by pressing red button or by saving the project with `CTRL + S` shortcut\n![STM32CubeIDE - 7](docs/images/cubeide-7.png)\n\nProject is now (re)generated. *Yellow* highlighted files are sources to build. *Blue* is linker script.\n![STM32CubeIDE - 8](docs/images/cubeide-8.png)\n\nThat's it for the first run, we are ready to compile. Hit `CTRL + B` or click on *hammer* icon to start.\n*STM32CubeIDE* will compile the project, you should see similar as on picture below. It is now ready for flashing the MCU's flash and start debugging.\n![STM32CubeIDE - 9](docs/images/cubeide-9.png)\n\n\u003e This is end of first part, where we successfully created our project. At this point we consider project being ready to be transferred to CMake-based build system.\n\nYou can continue your development with STM32CubeIDE in the future, add new sources, modify code, compile, flash the binary and debug directly the microcontroller.\nThis is preferred STM32 development studio, developed and maintained by STMicroelectronics.\n\n# CMake configuration\n\nIt is expected that project to develop in VSCode has been created. We will move forward for GCC compiler, but others could be used too.\n\nWith release of Visual Studio Code, many developers use the tool for many programming languages and fortunately can also develop STM32 applications with single tool.\nIf you are one of developers liking VSCode, most elegant way to move forward is to transfer STM32CubeIDE-based project to *CMake*, develop code in VSCode and compile with Ninja build system using GCC compiler. It is fast and lightweight.\n\n\u003e Development in VSCode is for intermediate or experienced users. I suggest to all STM32 beginners to stay with *STM32CubeIDE* development toolchain. It will be very easy to move forward and come to VSCode topic later.\n\n## Prepare CMakeLists.txt file\n\nEvery CMake-based application requires `CMakeLists.txt` file *in the root directory*, that describes the project and provides input information for build system generation.\n\n\u003e Root `CMakeLists.txt` file is sometimes called *top-level CMake* file\n\nEssential things described in `CMakeLists.txt` file:\n\n- Toolchain information, such as GCC configuration with build flags\n- Project name\n- Source files to build with compiler, C, C++ or Assembly files\n- List of include paths for compiler to find functions, defines, ... (`-I`)\n- Linker script path\n- Compilation defines, or sometimes called *preprocessor defines* (`-D`)\n- Cortex-Mxx and floating point settings for instruction set generation\n\n## Open VSCode in project root folder\n\nVisual Studio Code has been installed and will be used as further file editor.\n\nFind your generated project path and open folder with VSCode:\n\n- Option 1: Go to the folder with explorer, then right click and select `Open in Code`.\n- Option 2: Alternatively, open VScode as new empty solution and add folder to it manually. Use `File -\u003e Open Folder...` to open folder\n- Option 3: Go to folder with cmd or powershell tool and run `code .`\n\nFinal result should look similar to the one below\n![VSCode - Folder is open](docs/images/vscode-1.png)\n\n## Toolchain information\n\nCMake needs to be aware about Toolchain we would like to use to finally compile the project with.\nAs same toolchain is usually reused among different projects, it is advised to create this part in separate file for easier reuse. These are generic compiler settings and not directly linked to projects itself.\n\nA simple `.cmake` file can be used and later reused among your various projects. I am using name `cmake/gcc-arm-none-eabi.cmake` for this tutorial and below is its example:\n\n```cmake\nset(CMAKE_SYSTEM_NAME               Generic)\nset(CMAKE_SYSTEM_PROCESSOR          arm)\n\n# Some default GCC settings\n# arm-none-eabi- must be part of path environment\nset(TOOLCHAIN_PREFIX                arm-none-eabi-)\nset(FLAGS                           \"-fdata-sections -ffunction-sections --specs=nano.specs -Wl,--gc-sections\")\nset(CPP_FLAGS                       \"-fno-rtti -fno-exceptions -fno-threadsafe-statics\")\n\n# Define compiler settings\nset(CMAKE_C_COMPILER                ${TOOLCHAIN_PREFIX}gcc ${FLAGS})\nset(CMAKE_ASM_COMPILER              ${CMAKE_C_COMPILER})\nset(CMAKE_CXX_COMPILER              ${TOOLCHAIN_PREFIX}g++ ${FLAGS} ${CPP_FLAGS})\nset(CMAKE_OBJCOPY                   ${TOOLCHAIN_PREFIX}objcopy)\nset(CMAKE_SIZE                      ${TOOLCHAIN_PREFIX}size)\n\nset(CMAKE_EXECUTABLE_SUFFIX_ASM     \".elf\")\nset(CMAKE_EXECUTABLE_SUFFIX_C       \".elf\")\nset(CMAKE_EXECUTABLE_SUFFIX_CXX     \".elf\")\n\nset(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)\n```\n\nCreate a file in the `cmake/` folder of root project directory.\n![VSCode - 2 - CMake - Toolchain](docs/images/vscode-2-cmake-toolchain.png)\n\n\u003e If CMake highlighter plugin is installed, VSCode will nicely highlight CMake commands for you\n\nToolchain setup is complete. You can freely close the file and move to next step.\n\n## Create main CMakeLists.txt file\n\nWe need to create main `CMakeLists.txt`, also called *root* CMake file.\n\n\u003e Make sure you really name it `CMakeLists.txt` with correct upper and lowercase characters.\n\nI prepared simple template file for you, that can be reused for all of your projects in the future. You will just need to change things like project name, source files, include paths, etc.\n\n```cmake\ncmake_minimum_required(VERSION 3.22)\n\n# Setup compiler settings\nset(CMAKE_C_STANDARD                11)\nset(CMAKE_C_STANDARD_REQUIRED       ON)\nset(CMAKE_C_EXTENSIONS              ON)\nset(CMAKE_CXX_STANDARD              20)\nset(CMAKE_CXX_STANDARD_REQUIRED     ON)\nset(CMAKE_CXX_EXTENSIONS            ON)\nset(PROJ_PATH                       ${CMAKE_CURRENT_SOURCE_DIR})\nmessage(\"Build type: \"              ${CMAKE_BUILD_TYPE})\n\n#\n# Core project settings\n#\nproject(your-project-name)\nenable_language(C CXX ASM)\n\n#\n# Core MCU flags, CPU, instruction set and FPU setup\n# Needs to be set properly for your MCU\n#\nset(CPU_PARAMETERS\n    -mthumb\n\n    # This needs attention to properly set for used MCU\n    -mcpu=cortex-m7\n    -mfpu=fpv5-d16\n    -mfloat-abi=hard\n)\n\n# Set linker script\nset(linker_script_SRC               ${PROJ_PATH}/path-to-linker-script.ld)\nset(EXECUTABLE                      ${CMAKE_PROJECT_NAME})\n\n#\n# List of source files to compile\n#\nset(sources_SRCS\n    # Put here your source files, one in each line, relative to CMakeLists.txt file location\n)\n\n#\n# Include directories\n#\nset(include_path_DIRS\n    # Put here your include dirs, one in each line, relative to CMakeLists.txt file location\n)\n\n#\n# Symbols definition\n#\nset(symbols_SYMB\n    # Put here your symbols (preprocessor defines), one in each line\n    # Encapsulate them with double quotes for safety purpose\n)\n\n# Executable files\nadd_executable(${EXECUTABLE} ${sources_SRCS})\n\n# Include paths\ntarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})\n\n# Project symbols\ntarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})\n\n# Compiler options\ntarget_compile_options(${EXECUTABLE} PRIVATE\n    ${CPU_PARAMETERS}\n    -Wall\n    -Wextra\n    -Wpedantic\n    -Wno-unused-parameter\n    # Full debug configuration\n    -Og -g3 -ggdb\n)\n\n# Linker options\ntarget_link_options(${EXECUTABLE} PRIVATE\n    -T${linker_script_SRC}\n    ${CPU_PARAMETERS}\n    -Wl,-Map=${CMAKE_PROJECT_NAME}.map\n    --specs=nosys.specs\n    -u _printf_float                # STDIO float formatting support\n    -Wl,--start-group\n    -lc\n    -lm\n    -lstdc++\n    -lsupc++\n    -Wl,--end-group\n    -Wl,--print-memory-usage\n)\n\n# Execute post-build to print size\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_SIZE} $\u003cTARGET_FILE:${EXECUTABLE}\u003e\n)\n\n# Convert output to hex and binary\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O ihex $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.hex\n)\n\n# Convert to bin file -\u003e add conditional check?\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O binary $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.bin\n)\n```\n\nSource files are the same as in *STM32CubeIDE* project. You can check previous image with highlighted sources in yellow color.\n\nSymbols and include paths can be found in *STM32CubeIDE* under project settings. `2` pictures below are showing how it is in the case of demo project.\n\n![STM32CubeIDE - include paths](docs/images/cubeide-include-paths.png)\n![STM32CubeIDE - symbols](docs/images/cubeide-symbols.png)\n\nCortex-Mxx setup needs a special attention, especially with floating point setup.\nFor `STM32H735xx`, settings should be set as below. \n```cmake\nset(CPU_PARAMETERS\n    -mthumb\n    -mcpu=cortex-m7         # Set Cortex-M CPU\n    -mfpu=fpv5-d16          # Set Floating point type\n    -mfloat-abi=hard        # Hardware ABI mode\n)\n```\n![STM32CubeIDE - MCU settings](docs/images/cubeide-mcu-settings.png)\n\nGeneral rule for settings would be as per table below\n\n|STM32 Family | -mcpu           | -mfpu         | -mfloat-abi |\n|-------------|-----------------|---------------|-------------|\n| STM32F0     | `cortex-m0`     | `Not used`    | `soft`      |\n| STM32F1     | `cortex-m3`     | `Not used`    | `soft`      |\n| STM32F2     | `cortex-m3`     | `Not used`    | `soft`      |\n| STM32F3     | `cortex-m4`     | `fpv4-sp-d16` | `hard`      |\n| STM32F4     | `cortex-m4`     | `fpv4-sp-d16` | `hard`      |\n| STM32F7 SP  | `cortex-m7`     | `fpv5-sp-d16` | `hard`      |\n| STM32F7 DP  | `cortex-m7`     | `fpv5-d16`    | `hard`      |\n| STM32G0     | `cortex-m0plus` | `Not used`    | `soft`      |\n| STM32C0     | `cortex-m0plus` | `Not used`    | `soft`      |\n| STM32G4     | `cortex-m4`     | `fpv4-sp-d16` | `hard`      |\n| STM32H5     | `cortex-m33`    | `fpv5-sp-d16` | `hard`      |\n| STM32H7     | `cortex-m7`     | `fpv5-d16`    | `hard`      |\n| STM32L0     | `cortex-m0plus` | `Not used`    | `soft`      |\n| STM32L1     | `cortex-m3`     | `Not used`    | `soft`      |\n| STM32L4     | `cortex-m4`     | `fpv4-sp-d16` | `hard`      |\n| STM32L5     | `cortex-m33`    | `fpv5-sp-d16` | `hard`      |\n| STM32U0     | `cortex-m0plus` | `Not used`    | `soft`      |\n| STM32U5     | `cortex-m33`    | `fpv5-sp-d16` | `hard`      |\n| STM32WB     | `cortex-m4`     | `fpv4-sp-d16` | `hard`      |\n| STM32WBA    | `cortex-m33`    | `fpv5-sp-d16` | `hard`      |\n| STM32WL CM4 | `cortex-m4`     | `Not used`    | `soft`      |\n| STM32WL CM0 | `cortex-m0plus` | `Not used`    | `soft`      |\n\n\u003e This table is a subject of potential mistakes, not tested with *GCC compiler* for all lines. For `STM32F7`, go to [STM32F7xx official site](https://www.st.com/en/microcontrollers-microprocessors/stm32f7-series.html) and check if your device has single or double precision FPU, then apply settings accordingly.\n\u003e Products list is not exhaustive.\n\nFinal `CMakeLists.txt` file after source files, include paths, MCU core settings and defines are set:\n```cmake\ncmake_minimum_required(VERSION 3.22)\n\n# Setup compiler settings\nset(CMAKE_C_STANDARD                11)\nset(CMAKE_C_STANDARD_REQUIRED       ON)\nset(CMAKE_C_EXTENSIONS              ON)\nset(CMAKE_CXX_STANDARD              20)\nset(CMAKE_CXX_STANDARD_REQUIRED     ON)\nset(CMAKE_CXX_EXTENSIONS            ON)\nset(PROJ_PATH                       ${CMAKE_CURRENT_SOURCE_DIR})\nmessage(\"Build type: \"              ${CMAKE_BUILD_TYPE})\n\n#\n# Core project settings\n#\nproject(STM32H735G-DK-LED)          # Modified\nenable_language(C CXX ASM)\n\n#\n# Core MCU flags, CPU, instruction set and FPU setup\n# Needs to be set properly for your MCU\n#\nset(CPU_PARAMETERS\n    -mthumb\n\n    # This needs attention to properly set for used MCU\n    -mcpu=cortex-m7                 # Modified\n    -mfpu=fpv5-d16                  # Modified\n    -mfloat-abi=hard                # Modified\n)\n\n# Set linker script\nset(linker_script_SRC               ${PROJ_PATH}/STM32H735IGKX_FLASH.ld) # Modified\nset(EXECUTABLE                      ${CMAKE_PROJECT_NAME})\n\n#\n# List of source files to compile\n#\nset(sources_SRCS                    # Modified\n    ${PROJ_PATH}/Core/Src/main.c\n    ${PROJ_PATH}/Core/Src/stm32h7xx_it.c\n    ${PROJ_PATH}/Core/Src/syscalls.c\n    ${PROJ_PATH}/Core/Src/sysmem.c\n    ${PROJ_PATH}/Core/Src/system_stm32h7xx.c\n    ${PROJ_PATH}/Core/Startup/startup_stm32h735igkx.s\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_exti.c\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_gpio.c\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_pwr.c\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_rcc.c\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_ll_utils.c\n)\n\n#\n# Include directories\n#\nset(include_path_DIRS               # Modified\n    ${PROJ_PATH}/Core/Inc\n    ${PROJ_PATH}/Drivers/STM32H7xx_HAL_Driver/Inc\n    ${PROJ_PATH}/Drivers/CMSIS/Device/ST/STM32H7xx/Include\n    ${PROJ_PATH}/Drivers/CMSIS/Include\n)\n\n#\n# Symbols definition\n#\nset(symbols_SYMB                    # Modified\n    \"DEBUG\"\n    \"STM32H735xx\"\n    \"USE_FULL_LL_DRIVER\"\n    \"HSE_VALUE=25000000\"\n)\n\n# Executable files\nadd_executable(${EXECUTABLE} ${sources_SRCS})\n\n# Include paths\ntarget_include_directories(${EXECUTABLE} PRIVATE ${include_path_DIRS})\n\n# Project symbols\ntarget_compile_definitions(${EXECUTABLE} PRIVATE ${symbols_SYMB})\n\n# Compiler options\ntarget_compile_options(${EXECUTABLE} PRIVATE\n    ${CPU_PARAMETERS}\n    -Wall\n    -Wextra\n    -Wpedantic\n    -Wno-unused-parameter\n    # Full debug configuration\n    -Og -g3 -ggdb\n)\n\n# Linker options\ntarget_link_options(${EXECUTABLE} PRIVATE\n    -T${linker_script_SRC}\n    ${CPU_PARAMETERS}\n    -Wl,-Map=${CMAKE_PROJECT_NAME}.map\n    --specs=nosys.specs\n    -u _printf_float                # STDIO float formatting support\n    -Wl,--start-group\n    -lc\n    -lm\n    -lstdc++\n    -lsupc++\n    -Wl,--end-group\n    -Wl,--print-memory-usage\n)\n\n# Execute post-build to print size\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_SIZE} $\u003cTARGET_FILE:${EXECUTABLE}\u003e\n)\n\n# Convert output to hex and binary\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O ihex $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.hex\n)\n\n# Convert to bin file -\u003e add conditional check?\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O binary $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.bin\n)\n```\n\nIn VSCode, well highlighted, it looks like this\n![VSCode - final CMakeLists.txt](docs/images/vscode-3-cmake-final.png)\n\n## Create preset CMakePresets.json file\n\n`CMakePresets.json` is a special file, available since CMake `3.18` and provides definition for user configuration, similar to *debug* and *release* configuration known in eclipse. Having this file allows developer to quickly change between *debug* and *release* mode, or even between *bootloader* and *main application*, that is a common use case in embedded applications.\n\n\u003e This tutorial will not focus on details about the file, rather here is the provided template file\n\nFile describes:\n- Path to build directory for each build configuration\n- Default build type for each configuration (*Debug*, *Release*, ...)\n- Path to *.cmake* toolchain descriptor\n\n\u003e `4` presets are configured in the template for each of the default *CMake* configurations\n\n```json\n{\n    \"version\": 3,\n    \"configurePresets\": [\n        {\n            \"name\": \"default\",\n            \"hidden\": true,\n            \"generator\": \"Ninja\",\n            \"binaryDir\": \"${sourceDir}/build/${presetName}\",\n            \"toolchainFile\": \"${sourceDir}/cmake/gcc-arm-none-eabi.cmake\",\n            \"cacheVariables\": {\n                \"CMAKE_EXPORT_COMPILE_COMMANDS\": \"ON\"\n            }\n        },\n        {\n            \"name\": \"Debug\",\n            \"inherits\": \"default\",\n            \"cacheVariables\": {\n                \"CMAKE_BUILD_TYPE\": \"Debug\"\n            }\n        },\n        {\n            \"name\": \"RelWithDebInfo\",\n            \"inherits\": \"default\",\n            \"cacheVariables\": {\n                \"CMAKE_BUILD_TYPE\": \"RelWithDebInfo\"\n            }\n        },\n        {\n            \"name\": \"Release\",\n            \"inherits\": \"default\",\n            \"cacheVariables\": {\n                \"CMAKE_BUILD_TYPE\": \"Release\"\n            }\n        },\n        {\n            \"name\": \"MinSizeRel\",\n            \"inherits\": \"default\",\n            \"cacheVariables\": {\n                \"CMAKE_BUILD_TYPE\": \"MinSizeRel\"\n            }\n        }\n    ]\n}\n```\n\u003e Always up-to-date file is available in `templates/CMakePresets.json`\n\n## Run CMake commands\n\nWe have configured *CMake* with project information and are now ready to run the CMake commands.\n\nVSCode comes with *CMake Tools* plugin - a great helper for CMake commands. When installed, several options are available at the bottom of the VSCode active window\n\n![VSCode - Default CMake Tools plugin view](docs/images/vscode-5-cmake-tools-window-default.png)\n\nAs you can see, there is no Configuration Preset selected.\n\n\u003e If you do not see such information, hit `CTRl + ALT + P` and run `CMake: Quick Start` command.\n\nNext step is to select current *preset*. Click on *No Configure Preset Selected* to open a window on top side and select your *preset*. I selected *debug* for the sake of this tutorial.\n\n![VSCode - Select application preset](docs/images/vscode-6-cmake-tools-select-preset.png)\n\nWhen selected, text will change to selected *preset label*.\n\n![VSCode - Preset selected](docs/images/vscode-7-cmake-tools-preset-selected-run-build.png)\n\nNow that preset is active, every time user will modify `CMakeLists.txt` file, thanks to *CMake-Tools* extension, VSCode will automatically invoke build generation command to apply new changes.\n\n# Build project\n\nOur project is ready for building and linking. Unless CMake build generation step failed, we should have build directory ready to invoke *ninja build system*.\n\nNext step is to hit *Build* button - as indicated with green rectangle. CMake will run commands:\n\n- Run build generator for selected preset\n- Actually build code with *Ninja*\n\n![VSCode - Preset selected](docs/images/vscode-9-build-finish.png)\n\n\u003e If it builds well, final step on the output is print of memory use with different sections.\n\nAs a result, we got some output in `build/\u003cpresetname\u003e/` directory:\n\n- `project-name.elf` file with complete executable information\n- `project-name.hex` HEX file\n- `project-name.bin` BIN file\n- `project-name.map` map file\n\nIn default configuration, `.hex` and `.bin` files are not generated nor *memory usage* is displayed.\nOur prepared `CMakeLists.txt` file includes `POST_BUILD` options, to execute additional commands after successful build.\nCode is already in your `CMakeLists.txt` file, so no need to do anything, just observe.\n\nIt executes command to:\n- Print used size of each region + final executable memory consumption\n- Generate `.hex` file from executable\n- Generate `.bin` file from executable\n\n```cmake\n# Execute post-build to print size\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_SIZE} $\u003cTARGET_FILE:${EXECUTABLE}\u003e\n)\n\n# Convert output to hex and binary\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O ihex $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.hex\n)\n\n# Convert to bin file -\u003e add conditional check?\nadd_custom_command(TARGET ${EXECUTABLE} POST_BUILD\n    COMMAND ${CMAKE_OBJCOPY} -O binary $\u003cTARGET_FILE:${EXECUTABLE}\u003e ${EXECUTABLE}.bin\n)\n```\n\n\u003e To disable `.bin` file generation, simply delete `POST_BUILD` line for `.bin` and regenerate CMake build system commands.\n\u003e Generating `.bin` files may have a negative effect when memory is split between internal and external flash memories. It may generate very large files (`\u003e= 2GB`) with plenty of non-used zeros. \n\nThere is a list of useful commands to keep in mind during project development:\n\n- Build changes\n- Clean project\n- Re-build project, with clean first\n- Flash project\n\nIts easy to forget full syntax, rather let's create `.vscode/tasks.json` file with commands list, for quick run:\n```json\n{\n\t\"version\": \"2.0.0\",\n\t\"tasks\": [\n        {\n            \"type\": \"cppbuild\",\n            \"label\": \"Build project\",\n            \"command\": \"cmake\",\n            \"args\": [\"--build\", \"${command:cmake.buildDirectory}\", \"-j\", \"8\"],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": [\"$gcc\"],\n            \"group\": {\n                \"kind\": \"build\",\n                \"isDefault\": true\n            }\n        },\n        {\n            \"type\": \"shell\",\n            \"label\": \"Re-build project\",\n            \"command\": \"cmake\",\n            \"args\": [\"--build\", \"${command:cmake.buildDirectory}\", \"--clean-first\", \"-v\", \"-j\", \"8\"],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": [\"$gcc\"],\n        },\n        {\n            \"type\": \"shell\",\n            \"label\": \"Clean project\",\n            \"command\": \"cmake\",\n            \"args\": [\"--build\", \"${command:cmake.buildDirectory}\", \"--target\", \"clean\"],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": []\n        },\n        {\n            \"type\": \"shell\",\n            \"label\": \"CubeProg: Flash project (SWD)\",\n            \"command\": \"STM32_Programmer_CLI\",\n            \"args\": [\n                \"--connect\",\n                \"port=swd\",\n                \"--download\", \"${command:cmake.launchTargetPath}\",\n                \"-hardRst\"\n            ],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": []\n        },\n        {\n            \"type\": \"shell\",\n            \"label\": \"CubeProg: Flash project with defined serial number (SWD) - you must set serial number first\",\n            \"command\": \"STM32_Programmer_CLI\",\n            \"args\": [\n                \"--connect\",\n                \"port=swd\",\n                \"sn=\u003cyourserialnumber\u003e\",\n                \"--download\", \"${command:cmake.launchTargetPath}\",\n                \"-hardRst\"\n            ],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": []\n        },\n        {\n            \"type\": \"shell\",\n            \"label\": \"CubeProg: List all available communication interfaces\",\n            \"command\": \"STM32_Programmer_CLI\",\n            \"args\": [\n                \"--list\",\n            ],\n            \"options\": {\n                \"cwd\": \"${workspaceFolder}\"\n            },\n            \"problemMatcher\": []\n        },\n    ]\n}\n```\n\u003e Always up-to-date file is available in `templates/.vscode/tasks.json`\n\nTasks defined in `tasks.json` can be invoked in VSCode interface using `Terminal -\u003e Run Task` or with `CTRL + ALT + T` shortcut\n![VSCode - Tasks.json file](docs/images/vscode-10-tasks.png)\n\n*Build Project* task is configured as *default*, which will get executed when we run default task, or press shortcut `CTRL + SHIFT + B`.\n\n```json\n\"group\": {\n    \"kind\": \"build\",\n    \"isDefault\": true\n}\n```\n\n## List project files with CMake-Tools plugin\n\n*CMake-Tools* VSCode plugin comes with very nice feature, that being listing all files in the project.\nWhen project uses files outside *root folder* tree, there is no way to see them in VSCode by default, unless you add another folder to project workspace, but then you *destroy* some of the features listed above.\n\n*CMake-Tools* extension well parses `CMakeLists.txt` file and is able to display all the source files, currently part of the CMake build system generation and later part of GCC build thanks to *Ninja*.\nOn the left side of the screen, you will find an icon for *CMake* build, marked red on picture below.\n![VSCode - List files part of CMake build system generation](docs/images/vscode-cmake-tools-list-files.png)\n\nIt draws virtual folder tree according to source (executable) files path listed in `CMakeLists.txt` file.\n\nFor the sake of this demonstration purpose, I created a file `demo_file.c`, one folder up from `CMakeLists.txt` location and added it to the project.\nAfter CMake build system generation, we can see virtual file added in *CMake-Tools browser*.\n![VSCode - List files part of CMake build system generation](docs/images/vscode-cmake-tools-list-files-ext.png)\n\nThanks to this feature, we can have a full control over files being part of build and can quickly find files to modify, even if these are outside workspace folder directory.\n\n## GCC Problem matcher\n\nAnother nice *Build Project* task parameter is `\"problemMatcher\": [\"$gcc\"],` set to GCC, which means that terminal output is parsed against GCC standard format and in case of warnings or errors, it will display nice messages in *Problems* view.\n![VSCode - Tasks.json file](docs/images/vscode-10-tasks-1.png)\n\nWe reached at the end of CMake configuration and build setup.\nYou can freely modify C source code and and/remove files from/to project.\nThis is now fully working GCC-based compilation system running in VSCode.\n\n\u003e Do not forget to regenerate CMake when `CMakeLists.txt` file gets modified, or use *Build* button to do it for you.\n\n## Stop receiving virtual C/C++ errors\n\nAs you may have noticed, some lines in C files are red-underlined, reporting a `could not find resource` error, but when compiled, all is working just fine.\n![VSCode - Debug session](docs/images/vscode-dbg-1.png)\n\nThis is reported by `CppTools` extension as it cannot find resources by default, as Intellisense is not aware of include paths or preprocessor defines.\n\n\u003e It will still compile well as include paths are defined in `CMakeLists.txt`, just VSCode Intellisense editor won't work by default.\n\nTo overcome this problem, let's create `.vscode/c_cpp_properties.json` file and copy below text to it\n```json\n{\n    \"version\": 4,\n    \"configurations\": [\n        {\n            /* \n             * ms-vscode.cmake-tools plugin should be installed.\n             * \n             * It provides data for C/C++ plugin,\n             * such as include paths, browse paths, defines, etc.\n             */\n            \"name\": \"STM32\",\n            \"configurationProvider\": \"ms-vscode.cmake-tools\",\n            \"intelliSenseMode\": \"${default}\"\n        }\n    ]\n}\n```\n\u003e Always up-to-date file is available in `templates/.vscode/c_cpp_properties.json`\n\n![VSCode - C/C++ virtual errors](docs/images/vscode-c-cpp-1-file.png)\n\nWe provided settings for `C/C++` extension, mainly for Intellisense feature, and configure it in a way to use `CMake-Tools` extension to find include paths and list of defines (preprocessor defined).\n\nNo errors are visible anymore and Intellisense is now fully operational.\nYou can test it by going to one resource (ex. with mouse over a function name), then click `CTRL + left mouse click` command and you should jump to definition location directly.\n![VSCode - No errors anymore](docs/images/vscode-c-cpp-2-no-errors.png)\n\n\u003e `.vscode/c_cpp_properties.json` is used for `CppTools` extension purpose.\n\n# Debug project with cortex-debug\n\nOur `.elf` file has been built in previous section and can't wait to be uploaded into MCU flash and executed by *Cortex-M core*.\nWe will use `Cortex-Debug` extension for debugging purpose, that will also flash firmware for us.\n\nFirst thing is to create `.vscode/launch.json` file and copy below content to it:\n\n```json\n{\n    \"version\": \"0.2.0\",\n    \"configurations\": [\n        {\n            \"name\": \"Debug Microcontroller - STLink-V3\",\n            \"cwd\": \"${workspaceFolder}\",        //Path from where commands are executed\n            \"type\": \"cortex-debug\",             //Debug \n            \"executable\": \"${command:cmake.launchTargetPath}\", //or fixed file path: build/project-name.elf\n            \"request\": \"launch\",                //Use \"attach\" to connect to target w/o elf download\n            \"servertype\": \"stlink\",             //Use stlink setup of cortex-M debug\n            \"device\": \"STM32H735IG\",            //MCU used\n            \"interface\": \"swd\",                 //Interface setup\n            \"serialNumber\": \"\",                 //Set ST-Link ID if you use multiple at the same time\n            \"runToEntryPoint\": \"main\",          //Run to main and stop there\n            \"svdFile\": \"STM32H73x.svd\",         //SVD file to see reisters\n            \"v1\": false,\n            \"showDevDebugOutput\": \"both\",\n\n            /* Will get automatically detected if STM32CubeIDE is installed to default directory\n               or it can be manually provided if necessary.. */\n            //\"serverpath\": \"c:\\\\ST\\\\STM32CubeIDE_1.7.0\\\\STM32CubeIDE\\\\plugins\\\\com.st.stm32cube.ide.mcu.externaltools.stlink-gdb-server.win32_2.0.100.202109301221\\\\tools\\\\bin\\\\ST-LINK_gdbserver.exe\",\n            //\"armToolchainPath\": \"c:\\\\ST\\\\STM32CubeIDE_1.7.0\\\\STM32CubeIDE\\\\plugins\\\\com.st.stm32cube.ide.mcu.externaltools.gnu-tools-for-stm32.9-2020-q2-update.win32_2.0.0.202105311346\\\\tools\\\\bin\",\n            //\"stm32cubeprogrammer\": \"c:\\\\Program Files\\\\STMicroelectronics\\\\STM32Cube\\\\STM32CubeProgrammer\\\\bin\",\n\n            /* If you use external loader, add additional arguments */\n            //\"serverArgs\": [\"--extload\", \"path/to/ext/loader.stldr\"],\n        }\n    ]\n}\n```\n\u003e Always up-to-date launch file is available in `templates/.vscode/launch.json`\n\nAnd you are ready to go! Hit `F5` and you should enter debug session with your MCU.\n![VSCode - Debug session](docs/images/vscode-dbg-1.png)\n\n\u003e Be sure to have ST-Link debug probe software at its latest version.\n\nExtension will invoke ST-GDBServer application, and will take `.elf` file as defined by *CMake* as target launch file.\n\n## Debug to main\n\n![VSCode - Debug session - breakpoints - step over - step into](docs/images/vscode-dbg-1.png)\n\nYou have full control over stepping and can set breakpoints like you would in STM32CubeIDE.\n\n## MCU registers with SVD\n\nIf you have MCU SVD file, add its path in `launch.json` configuration, and you will see all peripheral registers in MCU.\n![VSCode - Debug session - SVD](docs/images/vscode-dbg-3.png)\n\n## Memory view\n\nTo view memory, open command palette with `CTRL + SHIFT + P` and type `memory`\n\nFirst select command to view memory\n![VSCode - Debug session - Memory command](docs/images/vscode-dbg-4-memory.png)\nSelect memory start address\n![VSCode - Debug session - Memory address](docs/images/vscode-dbg-4-memory-address.png)\nAnd memory length to fetch\n![VSCode - Debug session - Memory length](docs/images/vscode-dbg-4-memory-len.png)\nNice view of MCU memory\n![VSCode - Debug session - Memory view](docs/images/vscode-dbg-4-memory-view.png)\n\n## Assembly stepping\n\nYou can step with assembly instructions\n\nOpen Command Palette and type `Cortex` and pick disassembly, then type function to disassemble.\nIt is possible to later step by step assembly instructions too.\n\n![VSCode - Debug session - Memory view](docs/images/vscode-dbg-5-disassembly.png)\n\nMany other features are available.\n\n# Conclusion\n\nThis is all for the tutorial.\nWe showed how to create first project with STM32CubeIDE or STM32CubeMX to have its structure, sources and graphical configuration, later transferred to VSCode, CMake and Cortex-debug.\n\nFull project from this tutorial is available in `cube-ide-cmake-demo-proj` folder\n\n# Automatic STM32CubeIDE script\n\nPart of this repository is also `stm32-cube-cmake-vscode.py` experimetal script, target being taking location of your STM32CubeIDE generated project as an input, finding `.cproject` and `.project` files and generate appropriate `CMakeLists.txt` file, to allow users to use VSCode environment, fully automatically.\n\n\u003e It is very experimental use case, however it works well for basic projects generated with STM32CubeIDE. It has not been tested extensively for the moment and bugs may still appear.\n\n## Features\n\n- Uses base project folder as input path parameter\n- Tries to find and parse .cproject and .project files\n- Parses linked files of .c, .cpp or .s types\n- Parses \"Source directories\" and scans for files inside. This is typical STM32CubeMX configuration where no \"linked-files\" are used, but \"source folders\" instead\n- Supports \"build\" configuration mode only, release configuration is considered advanced feature\n- Supports C, CXX and ASM compilers and linker\n- Generates include paths for each compiler type (C, CXX, ASM)\n- Generates symbols list for each compiler type (C, CXX, ASM)\n- Determines Cortex-Mxx from STM32xx name\n- Adjusts FPU and float-ABI settings\n- Finds linker script\n- Supports static library linkage\n- Tested with\n  - Simple project generated with STM32CubeMX for STM32H735 and STM32G474\n  - More complex project generated with TouchGFX-Designer\n    - All types of files\n    - C++, C, ASM, static library\n    - Linked files\n    - Source folders\n    . ...\n- Experimental purpose only\n\n## Tools needed:\n\n- VSCode with aforementioned extensions\n- CMake tool installed and in environment path\n- Ninja build system installed and in environment path\n- ARM none eabi compiler in environment path (comes with STM32CubeIDE)\n- STM32CubeIDE or STM32CubeMX to generate project\n- Python 3\n\n\u003e Following aforementioned tutorial will make sure all the tools are installed, except python.\n\n## How to use it\n\nRun script with arguments:\n```\npython stm32-cube-cmake-vscode [-f] --path \"path1\" [\"path2\" [\"pathn\", [...]]]\n```\n\nAs an example, giving demo projects in `script-projects/` dir, script shall be executed as\n```\npython stm32-cube-cmake-vscode [-f] --path \"script-projects/h735g-dk-touchgfx/\" \"script-projects/h735g-dk-usart/\"\n```\n`CMakeLists.txt` will be generated in the provided paths, but only if converter is able to find `.project` and `.cproject` files inside project directory\n\n## Known limitations\n\n- No support for dual-core devices\n- No support for Cortex-M33 with TrustZone configuration\n- Simple parsing of \"linker script\" field is too simple -\u003e needs stronger processing\n- Sometimes *.c and *.cpp from build are included\n\n## Contribution\n\nDo not hesitate to propose changes you believe will improve this script.\nIt should be a community project, work in synergy with worldwide ideas.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmajerle%2Fstm32-cube-cmake-vscode","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmajerle%2Fstm32-cube-cmake-vscode","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmajerle%2Fstm32-cube-cmake-vscode/lists"}