{"id":8934,"date":"2025-01-27T20:17:04","date_gmt":"2025-01-28T04:17:04","guid":{"rendered":"https:\/\/visualgdb.com\/w\/?p=8934"},"modified":"2025-01-30T15:00:53","modified_gmt":"2025-01-30T23:00:53","slug":"debugging-stm32h7r-s-applications-in-external-memory","status":"publish","type":"post","link":"https:\/\/visualgdb.com\/tutorials\/arm\/stm32\/stm32h7rs\/application\/","title":{"rendered":"Debugging STM32H7R\/S Applications in External Memory"},"content":{"rendered":"

This tutorial shows how to create an application project for the STM32H7R\/S device, that will reside in an external memory, and will be launched by a bootloader. Before you begin, follow this tutorial<\/a> to create a basic bootloader project.<\/p>\n

    \n
  1. In the solution containing the bootloader project, right-click on the solution node and select “Add->New Project”:\"\"<\/a><\/li>\n
  2. Select the same project type and device as you did when creating bootloader, but this time pick the Appli<\/strong> project instead of Boot <\/strong>in the Sample Selection<\/strong> page:
    \n    \"\"<\/a><\/li>\n
  3. In order to program the external memory, we will need to use the STM32CubeProgrammer<\/a> tool that requires the ELF files to have the .elf<\/strong> extension. This can be accomplished by adding the following line at the end of CMakeLists.txt<\/strong>:\n
    set_target_properties(<Executable Name> PROPERTIES SUFFIX \".elf\")<\/pre>\n
    \"\"<\/a><\/li>\n
  4. Build the project and verify that it got placed into XSPI2, and the FLASH memory is empty. If you still see the stats from the bootloader project, right-click on the STM32H7S_App<\/strong> project (with triangular CMake icon) and select “Set as startup project”:\"\"<\/a><\/li>\n
  5. Now we can test programming the FLASH memory with STM32CubeProgrammer. Go to its binary directory, and run the following command line:\n
    STM32_Programmer_CLI.exe -c port=SWD reset=HWrst -el ExternalLoader\\MX25UW25645G_NUCLEO-H7S3L8.stldr -w <full path to STM32H7S_App.elf><\/pre>\n
    \"\"<\/a><\/li>\n
  6. Once the programming succeeds, you can configure VisualGDB to run STM32CubeProgrammer automatically before each debug session. Add the following command as a pre-debug step:
    \n\n\n\n\n\n
    Command<\/td>\n<full path to STM32_Programmer_CLI.exe><\/td>\n<\/tr>\n
    Arguments<\/td>\nSTM32_Programmer_CLI.exe -c port=SWD reset=HWrst -el ExternalLoader\\MX25UW25645G_NUCLEO-H7S3L8.stldr -w $(TargetPath)<\/td>\n<\/tr>\n
    Working directory<\/td>\n<directory of STM32_Programmer_CLI.exe><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    \"\"<\/a><\/li>\n
  7. If we try to just debugging the application, GDB will try to directly program it into the FLASH memory and will fail. It will also assume that the FLASH memory is actually RAM that can be directly modified to set breakpoints, which is not the case. To work around it, change the following settings via VisualGDB Project Properties -> Debug Settings:
    \n\n\n\n\n
    Program FLASH memory<\/td>\nNever<\/td>\n<\/tr>\n
    Reset device<\/td>\nBefore programming + After programming<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    <\/a>Also add “mon gdb_breakpoint_override hard<\/strong>” to the startup GDB commands (requires using the ST fork of OpenOCD and not the discontinued H7R\/S OpenOCD branch):
    \n    \"\"<\/a><\/li>\n
  8. Set a breakpoint in the application’s main()<\/strong> function and press F5. VisualGDB will launch the application and the breakpoint will trigger:<\/li>\n
  9. \"\"<\/a>If you continue the application and connect the other port of the board to USB, it will get recognized as a virtual serial port:\"\"<\/a><\/li>\n
  10. Now we will show how to merge both the bootloader and the application into the same CMake project. Apply the following changes to CMakeLists.txt files:\n
      \n
    1. Add ALIAS BOOTLOADER_BSP<\/span> <\/strong>to the find_bsp()<\/strong><\/a> statement in the bootloader’s CMakeLists.txt file.<\/li>\n
    2. Add BSP_ALIAS BOOTLOADER_BSP<\/span>\u00a0 <\/strong>to the bsp_include_directories<\/span>()<\/strong>, bsp_compile_definitions<\/span>()<\/strong> and add_bsp_based_executable<\/span>( )<\/strong> statements. In this particular example, many include directories imported from the STM32 SDK are not needed as long as the project references the correct frameworks, so we have removed them in our example<\/a>.<\/li>\n
    3. Copy the find_bsp()<\/strong> statement and everything below it from the application’s CMakeLists.txt file.<\/li>\n<\/ol>\n
      This way you will end up with one CMakeLists.txt<\/strong> file defining two separate BSPs, each of them having one application. You can use this git commit<\/a> as a reference for the changes necessary to merge both projects.<\/li>\n
    4. Open VisualGDB Project Properties for the bootloader project and add a custom debug step similar to the one added before. Use $(TargetDir)\/(application name)<\/strong> instead of $(TargetPath)<\/strong>, as $(TargetPath)<\/strong> will now resolve to the bootloader binary:
      \n      \"\"<\/a><\/li>\n
    5. As the main application from VisualGDB’s view is now the bootloader, you can keep the FLASH programming turned on and don’t need to reset the device after programming. However, you still need to force the hardware breakpoints via gdb_breakpoint_override<\/strong>:\"\"<\/a><\/li>\n
    6. Finally, go to the Embedded Debug Tweaking<\/strong> page, expand the Related Executables<\/strong> list: and add the application there, checking the Symbols<\/strong> and Live Watch<\/strong> checkboxes, but not the FLASH<\/strong> checkbox. This will ensure that you can step set breakpoints in both the bootloader and the main application, but GDB will rely on the STM32CubeProgrammer (via a custom pre-debug step) to program the application into the external FLASH memory: \"\"<\/a><\/li>\n
    7. Having bootloader and application symbols loaded at the same time can cause confusion if both of them have variables with the same name (e.g. TickCount<\/strong>). If this happens, you can limit the debug symbols to application only by selecting it as the startup target (console icon in Solution Explorer), disabling the FLASH memory programming and enabling reset-after-program as shown here<\/a>:\"\"<\/a>This will reuse the existing bootloader, program the application and reset the device so that the bootloader takes control and launches the app.<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
      This tutorial shows how to create an application project for the STM32H7R\/S device, that will reside in an external memory,<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[89],"tags":[61],"_links":{"self":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/8934"}],"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=8934"}],"version-history":[{"count":6,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/8934\/revisions"}],"predecessor-version":[{"id":8957,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/posts\/8934\/revisions\/8957"}],"wp:attachment":[{"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/media?parent=8934"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/categories?post=8934"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/visualgdb.com\/w\/wp-json\/wp\/v2\/tags?post=8934"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}