{"id":6998,"date":"2020-10-21T15:41:56","date_gmt":"2020-10-21T22:41:56","guid":{"rendered":"https:\/\/visualgdb.com\/w\/?p=6998"},"modified":"2020-10-21T15:41:56","modified_gmt":"2020-10-21T22:41:56","slug":"creating-embedded-bootloader-projects-with-advanced-cmake","status":"publish","type":"post","link":"https:\/\/visualgdb.com\/tutorials\/arm\/bootloader\/cmake\/","title":{"rendered":"Creating Embedded Bootloader Projects with Advanced CMake"},"content":{"rendered":"

This tutorial shows how to use the Advanced CMake Project Subsystem to create a multi-target project consisting of a main application and a separate bootloader stored at the beginning of the FLASH memory:\"\"<\/a>This is a\u00a0simplified version of the GNU Make-based bootloader tutorial<\/a>. We will focus on CMake-specific aspects of bootloader projects, and will leave out details about interrupt handling and system calls that are described in the GNU Make-based tutorial.<\/p>\n

    \n
  1. Start Visual Studio and locate the VisualGDB Embedded Project Wizard:\"\"<\/a><\/li>\n
  2. Enter the name and location of the project: \"\"<\/a>Note that Advanced CMake projects can contain multiple targets, so the BootloaderDemo<\/strong> project shown here will contain both the main application and the bootloader.<\/li>\n
  3. Select “Create a new project -> Embedded Application -> Advanced CMake<\/strong>” and make sure the generation of .bin<\/strong> files is enabled:\"\"<\/a><\/li>\n
  4. On the next page of the wizard select the toolchain and the device you would like to target: \"\"<\/a><\/li>\n
  5. Proceed with the simplest LEDBlink<\/strong> sample:\"\"<\/a><\/li>\n
  6. Configure the debug settings that work with your board and click “Finish” to generate the project: \"\"<\/a><\/li>\n
  7. We will now replace the generated LEDBlink project with a very simple bootloader that will blink the LEDs twice and pass control to the main application. Locate the linker script in Solution Explorer, right-click on it and select “Copy to Project Directory<\/strong>“:
    \n    \"\"<\/a>Once the linker script is copied, we can modify it to reflect the memory layout used by the bootloader and the application. The only modification required on the bootloader side is to define the _app_start symbol to point to the start of the actual application (see the entire linker script here<\/a>):<\/p>\n
    _app_start = 0x08000000 + 0x4000;<\/pre>\n<\/li>\n
  8. Replace the contents of the main file with this code<\/a>. It will blink the on-board LEDs twice and then pass control to the main application by calling the function stored at the second slot after the _app_start<\/strong> address (we will later place the main application\u2019s reset handler there): \"\"<\/a><\/li>\n
  9. You can quickly test out the project by setting a breakpoint on the call to _app_start()<\/strong> and pressing F5 to begin debugging. Do not step into _app_start<\/strong> yet, as it doesn’t contain anything meaningful:\"\"<\/a><\/li>\n
  10. Now we will create a separate target for the main embedded application. Right-click on the project node in Solution Explorer and select Add->New Item<\/strong>: \"\"<\/a><\/li>\n
  11. Proceed with adding a new embedded executable: \"\"<\/a><\/li>\n
  12. In order to avoid confusion between the bootloader’s and application’s linker scripts, rename the one in the BootloaderDemo<\/strong> target to bootloader.lds<\/strong>: \"\"<\/a><\/li>\n
  13. Then copy the main application’s linker script file to the project directory and insert the .bootldr section in it:\n
    .bootldr :\r\n{\r\n    . = ALIGN(4);\r\n    KEEP(*(.bootldr))\r\n    FILL(0xFFFFFF)\r\n    . = 0x4000;\r\n} > FLASH<\/pre>\n
    You can find the entire linker script here<\/a>.<\/li>\n
  14. The last modification made to the linker script will place the .bootldr<\/strong> section at the beginning of the FLASH, however we still need make sure the contents of the BootloaderDemo<\/strong> target ends up in that section. Right-click on the TargetApplication<\/strong> node in Solution Explorer and select “Add->Embed Another Target<\/strong>“: \"\"<\/a><\/li>\n
  15. VisualGDB will ask for the target you would like to embed and will allow specifying the exact section name. Make sure the target gets placed in the .bootldr<\/strong> section: \"\"<\/a>Once you click OK, VisualGDB will automatically create an embed_target_output<\/a> statement, instructing the build system to embed the BootloaderDemo<\/strong> target into TargetApplication. You can always edit the statement in CMakeLists.txt to change this behavior, or use the properties in Solution Explorer to have VisualGDB edit it for you.<\/li>\n
  16. Right-click on the TargetApplication<\/strong> node in Solution Explorer and select “Set as Startup Target<\/strong>“:\"\"<\/a><\/li>\n
  17. Open VisualGDB Project Properties and enable the “Reset after programming<\/strong>” option on the Debug Settings page:\"\"<\/a>Note that for Advanced CMake projects the debug settings are shared between all targets of the same project. When you press F5, VisualGDB will use the startup target selected in Solution Explorer. You can also debug a specific target by selecting the “Debug” command in its context menu.<\/li>\n
  18. Replace the contents of TargetApplication.cpp<\/strong> with this code<\/a> and try building the project. The build will fail due to the missing SystemInit()<\/strong> call:\"\"<\/a><\/li>\n
  19. You can reuse the system_stm32f4xx.c<\/strong> file from the bootloader by right-clicking on the application and selecting “Add->Existing Item<\/strong>“. Once it is added to the target, the project will build successfully. Note how most of the FLASH memory is occupied by the fixed-size bootloader block: \"\"<\/a><\/li>\n
  20. Press F5 to begin debugging. The LEDs will briefly blink a couple of times, indicating that the bootloader has finished running, and the main program loop will then begin:\"\"<\/a><\/li>\n<\/ol>\n
    You can find the project shown in this tutorial in our Github repository<\/a>.
    \nTo learn about handling interrupts in bootloader-based setups and using syscalls from the application to the bootloader, follow the second part of the     GNU Make-based bootloader tutorial<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
    This tutorial shows how to use the Advanced CMake Project Subsystem to create a multi-target project consisting of a main<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[222],"tags":[119],"_links":{"self":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/6998"}],"collection":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/comments?post=6998"}],"version-history":[{"count":2,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/6998\/revisions"}],"predecessor-version":[{"id":7021,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/6998\/revisions\/7021"}],"wp:attachment":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/media?parent=6998"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/categories?post=6998"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/tags?post=6998"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}