{"id":6113,"date":"2021-05-29T06:24:18","date_gmt":"2021-05-29T06:24:18","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=6113"},"modified":"2023-08-14T10:36:20","modified_gmt":"2023-08-14T05:06:20","slug":"freertos-lecture-32-understanding-arm-semi-hosting-feature","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/freertos-lecture-32-understanding-arm-semi-hosting-feature\/","title":{"rendered":"FreeRTOS Lecture 32 – Understanding ARM Semi-hosting feature"},"content":{"rendered":"
\n
\n
\n
\n

 <\/p>\n<\/div>\n

\n

Understanding ARM Semi-hosting feature <\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n

Now, let\u2019s print some data by the task handlers, and let\u2019s use some printf statements in order to print some logs. For that, you have to use ARM semihosting.<\/span><\/p>\n

ARM semihosting:<\/b><\/span><\/p>\n

ARM semihosting is a feature of the ARM Cortex M platform. As the name itself indicates, this feature takes the help of host software (Figure 1).<\/span><\/p>\n

We are using STM32 system workbench IDE with debugger and other features as host software. You have to take the help of the host software to exchange some debug-related information or message.<\/span><\/p>\n

\"Figure
Figure 1. Overview of semihosting.<\/span><\/figcaption><\/figure>\n

 <\/p>\n

For example, if you use printf in your embedded software, which is running on the target hardware. Let\u2019s say the target hardware is a Nucleo board. Then there is no need to implement printf library code in your embedded software, which runs on the target. That would consume lots of space. So, the technique here is you can use printf without using the native printf library on your embedded software. But take <\/span>the help of the printf library present in the host or to be specifically present in the host debugging software, which is your eclipse. This technique is called ARM semihosting. <\/span><\/span><\/p>\n

We actually use the technique of message transfers from embedded software running on your hardware to the IDE to implement some of the C library functions such as printf, scanf, etc. This is what we call as semihosting. <\/span><\/span><\/p>\n

The semihosting is a mechanism that allows target boards to exchange messages from the embedded software to the host computer, which is running a debugger. Remember that this semihosting works only when you put the IDE in debugging mode.<\/span><\/span><\/p>\n

 <\/p>\n

There is a small document, as shown in Figure 2. Please download that. There you will see the project settings you have to do in order to enable the ARM semihosting. There are three important steps:<\/span><\/p>\n

    \n
  1. You have to send some arguments to the GCC linker.<\/span><\/li>\n
  2. Do some debug configuration for your application. That means you have to send monitor arm semihosting enable command.<\/span><\/li>\n
  3. After that, in the main.c you have to call the initialise_monitor_handles() function. <\/span><\/li>\n<\/ol>\n

    The combination of all the above things will configure the semihosting in the openSTM32 system workbench.<\/span><\/p>\n

    \"Figure
    Figure 2. Settings to be made in order to enable the semihosting.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    Now let\u2019s do all these settings one by one.<\/span><\/p>\n

    1. First, let\u2019s set the linker arguments to enable the semihosting feature. For that, just copy the line shown in Figure 3 and go to the eclipse. <\/span><\/p>\n

    Now let\u2019s terminate the debugging session by clicking on the option shown in Figure 4. <\/span><\/p>\n

    Then go to the C\/C++ perspective (Figure 5). <\/span><\/p>\n

    After that, right-click on the project, go to properties (Figure 6), then go to C\/C++ build, go to settings (Figure 7), click on MCU GCC linker, then go to miscellaneous (Figure 8) and in linker flags tab just paste the copied line, as shown in Figure 9, after that click apply and ok (Figure 10).<\/span><\/p>\n

    \"Figure
    Figure 3. Linker settings to enable the semihosting.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 4. Option to terminate the debugging mode.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 5. Option for entering into C\/C++ perspective.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 6. Properties of current STM32 project.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 7. C\/ C++ build settings.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 8. Miscellaneous folder of MCU GCC linker.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 9. Making required linker settings.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 10. Applying the changes made.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    2. After that, let\u2019s do the second step, i.e., debug configuration of your application. <\/span><\/p>\n

    For that, right-click on your project, go to debug as and then go to debug configurations (Figure 11). Select your project, go to startup, just browse here, you will see run commands as shown in Figure 12 there you just write the monitor arm semihosting enable command. <\/span><\/p>\n

    Now click apply. After that, click close.<\/span><\/p>\n

    \"Figure
    Figure 11. Debug configurations of current STM32 project.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Figure
    Figure 12. Running semihosting enable command in debug configurations.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    3. Now the third step is in the main.c use the code marked in Figure 13. <\/span><\/p>\n

    First, let\u2019s call the initialise_monitor_handles() function as a very first function, as shown in Figure 14. It need not be the very first function, but it is better to call this before calling any printf statements. <\/span><\/p>\n

    Also, copy the extern of that function, i.e., extern void initialise_monitor_handles() and paste it in the main.c, as shown in Figure 15.<\/span><\/p>\n

    \"Figure
    Figure 13. Functions to be called in main.c.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    int main(void)
    \n{<\/p>\n

    initialise_monitor_handles();<\/p>\n

    \/\/1. Reset the RCC clock configuration to the default reset state.
    \n\/\/HSI ON, PLL OFF, HSE OFF, system clock = 16MHz, cpu_clock = 16MHz
    \nRCC_DeInit();<\/p>\n

    \"Figure
    Figure 14. Call for initialise_monitor_handles() function.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Understanding
    Figure 15. Prototype of initialise_monitor_handles() function.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    After that, you can get rid of syscalls.c, which is added by the OpenSTM32 system workbench. <\/span><\/p>\n

    Just right-click on that, go to the properties (Figure 16), and exclude that from the build (Figure 17) because we don\u2019t need that file. Click apply and then ok.<\/span><\/p>\n

    \"Understanding
    Figure 16. Properties of syscalls.c.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    \"Understanding
    Figure 17. Excluding syscalls.c from the build.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    Now let\u2019s try to build the project (Figure 18) and see whether it gives any error or not. <\/span><\/p>\n

    \"Understanding
    Figure 18. Building the project.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    See the logs in Figure 19. The project was built successfully without any errors.<\/span><\/p>\n

    \"Understanding
    Figure 19. Result of compilation.<\/span><\/figcaption><\/figure>\n

     <\/p>\n

    Summary:<\/span><\/strong><\/p>\n

    To enable the semihosting, you have to just do three things. <\/span><\/p>\n

    The first one is you have to provide linker arguments in order to work with semihosting. Figure 2 shows the linker arguments, which must be supplied to the linker. <\/span><\/p>\n

    The second step is to include the monitor arm semihosting enable command in the debug configurations of your project. That means whenever you debug the project, this command will be executed, which enables the semihosting feature. <\/span><\/p>\n

    After that, in the main function include the function call and prototype of the initialise_monitor_handles() function. <\/span><\/p>\n

     <\/p>\n

    After that, you can use your printf statement. Let\u2019s write \u201cThis is hello world example code \\n\u201d inside the printf function. Since you are using printf, include #include<stdio.h> header file, as shown in Figure 20. It is always better if you include stdint.h.<\/span><\/p>\n

    #include<\/span> \"stm32f4xx.h\"\r\n#include<\/span> \"FreeRTOS.h\"\r\n#include<\/span> \"task.h\"\r\n\r\nTaskHandle_t xTaskHandle1=NULL;\r\nTaskHandle_t xTaskHandle2=NULL;\r\n\r\n\/\/Task functions prototypes<\/span>\r\nvoid<\/span> vTask1_handler(void<\/span> *params);\r\nvoid<\/span> vTask2_handler(void<\/span> *params);\r\n\r\n\/\/used for semihosting<\/span>\r\nextern void initialise_monitor_handles();\r\n\r\n\r\nint<\/span> main(void<\/span>)\r\n{\r\n    initialise_monitor_handles();\r\n    printf<\/span>(\"This is hello world example code\\n\");\r\n\r\n    \/\/1. Reset the RCC clock configuration to the default reset state.<\/span>\r\n    \/\/HSI ON, PLL OFF, HSE OFF, system clock = 16MHz, cpu_clock = 16MHz<\/span>\r\n    RCC_DeInit();<\/pre>\n
     <\/p>\n
    \"Understanding
    Figure 20. Including the header files.<\/span><\/figcaption><\/figure>\n
     <\/p>\n
    Build the project once again. <\/span>Now the project is compiled successfully without any error. <\/span><\/p>\n
    Now in the task function, let\u2019s write printf(\u201cHello-World: From Task-1\\n\u201d), as shown in Figure 21. In task 2 handler also again print the same thing and write \u201cHello-World: From Task-2\\n\u201d.<\/span><\/p>\n
    void<\/span> vTask1_handler(void<\/span> *params)\r\n{\r\n    while<\/span>(1)\r\n    {\r\n        printf<\/span>(\"Hello-world: From Task-1\\n\");\r\n    }\r\n}\r\n\r\nvoid<\/span> vTask2_handler(void<\/span> *params)\r\n{\r\n    while<\/span>(1)\r\n    {\r\n        printf<\/span>(\"Hello-world: From Task-2\\n\");\r\n    }\r\n}<\/pre>\n
    Use of printf statements in task handlers<\/span><\/p>\n
     <\/p>\n
    Now let\u2019s test this code:<\/span><\/p>\n