Using ITM mechanism to debug stm32 microcontroller

Use ITM mechanism to debug stm32 microcontroller and implement printf and scanf.

1. Introduction to ITM

The ITM mechanism is a debugging mechanism and a new generation of debugging method. Before this, there was a more famous debugging method called semihosting.

Anyone who has written C language on a PC knows that printf can output to the console and scanf can get input from the console. The printf/scanf functions here are standard library functions. Using these functions of the operating system, we can easily debug the program. On embedded devices (such as the STM32 microcontroller platform), development tools (such as MDK/IAR) also provide standard library functions, and naturally also provide printf/scanf functions. So can these functions be used? The question is, where does printf output? And in most cases, there is no keyboard, so how can scanf be used to input?

As we all know, embedded devices generally use emulators, such as the common Jlink/ulink, which can achieve burning, single-stepping, breakpoints, variable viewing, etc. The emulator connects the PC and the microcontroller. Smart designers are considering whether it is possible to use the emulator to enable the microcontroller to use the PC screen and PC keyboard to achieve printf output and scanf key acquisition.
In other words, the following hello, world program

1. #include 

2. int main()  

3. {  

4.         //Hardware initialization  

5.         //....  

6.         printf("hello, world");  

7.         for(;;);  

8. }  

After this program is burned into the microcontroller, the emulator connects the microcontroller to the PC and starts online debugging. Then, this program will output "Hello, world" to the PC and display it in a window of the development tool (MDK/IAR, etc.).

This is equivalent to the MCU using the display/input devices of the PC to achieve its own output/input. This method can undoubtedly facilitate debugging for program developers.

There are many ways to implement this mechanism, the most famous ones are semihosting and ITM.
ITM is a new generation debugging mechanism launched by ARM after the launch of semihosting. Now let's try debugging in this way.

2. STM32 uses ITM to debug
MCU: stm32f207VG
Emulator: Jlink V8
IDE: MDK4.50

2.1 Hardware connection

The ITM mechanism requires the use of a SWD interface and the SWO line needs to be connected. The general four-wire SWD method (VCC SDCLK, SDIO, GND) is not acceptable. The standard 20-pin JTAG interface is acceptable. You only need to set the SWD interface in MDK.

2.2 Add a redirection file

Save the following file as any C file and add it to the project. Here is a brief description of this file. We should know that our program is running on the microcontroller, so why can printf be output to the MDK window? This is because printf in the standard library actually calls fputc to achieve output, so we need to write an fputc function ourselves. This function will use the registers provided by ITM (similar to USART) to achieve data transmission. The emulator will receive this data and send it to the PC.

In fact, if your microcontroller is connected to an LCD, you only need to re-implement the fputc function and output to the LCD, then when you call printf, the output will be on the LCD. This mechanism is called the redirection mechanism.

1. #include 

2.   

3. #define ITM_Port8(n)    (*((volatile unsigned char *)(0xE0000000+4*n)))  

4. #define ITM_Port16(n)   (*((volatile unsigned short*)(0xE0000000+4*n)))  

5. #define ITM_Port32(n)   (*((volatile unsigned long *)(0xE0000000+4*n)))  

6. #define DEMCR           (*((volatile unsigned long *)(0xE000EDFC)))  

7. #define TRCENA          0x01000000  

8.   

9. struct __FILE { int handle; /* Add whatever you need here */ };  

10.     FILE __stdout;  

11.     FILE __stdin;  

12.       

13. int fputc(int ch, FILE *f)   

14. {  

15.     if (DEMCR & TRCENA)   

16.     {  

17.         while (ITM_Port32(0) == 0);  

18.         ITM_Port8(0) = ch;  

19.     }  

20.     return(ch);  

21. }  

2.2 Configure JLINK's initialization configuration file.

Place the following file under your project and give it any name. Here I named it STM32DBG.ini
 

1. /******************************************************************************/  

2. /* STM32DBG.INI: STM32 Debugger Initialization File                           */  

3. /******************************************************************************/  

4. // <<

5. /******************************************************************************/  

6. /* This file is part of the uVision/ARM development tools.                    */  

7. /* Copyright (c) 2005-2007 Keil Software. All rights reserved.                */  

8. /* This software may only be used under the terms of a valid, current,        */  

9. /* end user licence from KEIL for a compatible version of KEIL software       */  

10. /* development tools. Nothing else gives you the right to use this software.  */  

11. /******************************************************************************/  

12.   

13.   

14. FUNC void DebugSetup (void) {  

15. // 

16. //   

17. //   

18. //   

19. //   

20. //   

21. //             

22. //             

23. //             

24. //             

25. //   

26. //   

27. //   

28. //   

29. //   

30. //   

31. //   

32. //   

33. _WDWORD(0xE0042004, 0x00000027);  // DBGMCU_CR  

34. _WDWORD(0xE000ED08, 0x20000000);   // Setup Vector Table Offset Register  

35. }  

36.   

37. DebugSetup();                       // Debugger Setup  

Here is a brief explanation of this file,
_WDWORD(0xE0042004, 0x00000027); // DBGMCU_CR
This sentence means that you want to write 0x000000027 to the address 0xE0042004. The meaning of each bit of this register is explained in detail in the comments. 0x27 means
        BIT0 DBG_SLEEP
        BIT1 DBG_STOP
        BIT2 DBG_STANDBY
        BIT5 TRACE_IOEN
Note that to use the ITM mechanism, BIT5 must be turned on.

Open the MDK project and modify it according to the figure below.

2.3 Configuration of JLINK in MDK

Note two points in the figure below:
1). The CoreClock here is 120M, because the author uses the stm32F207VG chip, and the clock is configured to 120M, so fill in 120M here. If you use stm32F10x, the clock is configured to 72M, then you need to fill in 72M here. That is, it needs to be consistent with the actual situation.
2). Finally, be sure to check 0 and remove the check marks on other bits. It is best to keep it consistent with this figure, except for CoreClock.

2.4 Burn the program and start debugging. As you can see, I inserted a printf statement in the program source code, and then you can see the output of the program according to the figure below.

3. Comprehensive version uses scanf and printf
3.1 Add retarget file
Save the following code as retarget.c and add it to the project.

[cpp] view plain copy

1. #pragma import(__use_no_semihosting_swi)  

2.   

3. struct __FILE { int handle; /* Add whatever you need here */ };  

4.     FILE __stdout;  

5.     FILE __stdin;  

6.       

7. int fputc(int ch, FILE *f)   

8. {  

9.     return ITM_SendChar(ch);  

10. }  

11.   

12. volatile int32_t ITM_RxBuffer;  

13. int fgetc(FILE *f)  

14. {  

15.   while (ITM_CheckChar() != 1) __NOP();  

16.   return (ITM_ReceiveChar());  

17. }  

18.   

19. int ferror(FILE *f)  

20. {  

21.     /* Your implementation of ferror */  

22.     return EOF;  

23. }  

24.   

25. void _ttywrch(int c)  

26. {  

27.     fputc(c, 0);  

28. }  

29.   

30. int __backspace()  

31. {  

32.     return 0;  

33. }  

34. void _sys_exit(int return_code)  

35. {  

36. label:  

37.     goto label;  /* endless loop */  

38. }  

3.2 Compile and run
Compile, burn, run, open the Debug (printf) viewer, and you can see the input, see the figure below

Here are some explanations about the retarget.c file.
1). The above code is actually modified from X:\Keil\ARM\Startup\Retarget.c. There are two functions that scanf depends on, fgetc and __backspace, which need to be implemented. If the __backespace function is missing, scanf cannot get input from the Debug Viewer Dialog window. In addition, the code provided above is just a demo to demonstrate the effect. It should be processed more perfectly when used in production. See reference [1].

2). The functions ITM_SendChar, ITM_CheckChar, and ITM_ReceiveChar are in the library file CMSIS\Include\core_cm3.h.

3) To view the symbolic reference relationship of the function, you can generate a detailed map file. Add the --verbose --list rtt.map option to the command line to generate a file named rtt.map.

4. Combining ITM and RTT (to be implemented)
grissiom wrote:
I suddenly thought that maybe we can make this semihost into a device, and then rt_console_set_device("semi") can directly use semihost to do finsh/rt_kprintf... I don't know if it is feasible...

prife: I don't know whether ITM reception supports interrupts. Currently, the reception of characters uses polling. It only makes sense if it is an interrupt. In this way, the ITM device can be made into an rtt device, and finsh can run in the Debug printf Viewer window. In the future, you only need to connect a jtag/SWD port to debug, and you don't need to connect a serial port line.

References
[1] MDK help. Indirect semihosting C library function dependencies
[2] MDK help ARM Development Tools.
         Debugger Adapter User's Guides
             J-Link/J-Trace User's Guide
         Libraries and Floating Point Support Referencee
         Libraries and Floating Point Support Guide

         Linker Reference Guid