AVR Freaks

Just for the sake of diversity, I also tried hooking up the Atmel-ICE I've got. All setting were kept the same, apart from the debugger, and the Frequency for Percepio Trace set to 2Mhz in clear. With Atmel-ICE not even the Control-Flow Trace works. More than happy with any further suggestions.

I managed to get it work, in case it helps anyone. I found in the Help of Atmel Studio 6.2 a section on Percepio Trace which does not seem to exist in Atmel Studio 7. In it there is code that is recommended to get the ITM Application Output to work:

#define ITM_TER *(volatile int*)0xE0000E00 // Trace Enable Register
#define ITM_TCR *(volatile int*)0xE0080E80 // Trace Control Register
#define ITM_STIM_8(n) *(volatile uint8_t*)(0xE0000000 + ((n) * 4)) // 8 Bit N < 32

void SWO_print_char(int port, char c);
void SWO_print_string(int port, const char *s);

void SWO_print_char(int port, char c)
{
    while ((ITM_STIM_8(port) & 1) == 0);
    ITM_STIM_8(port) = c;
}

void SWO_print_string(int port, const char *s)
{
    if ((ITM_TCR & 1) == 0) return;
    if ((ITM_TER & 1) == 0) return;
    while (*s) SWO_print_char(port, *s++);
    SWO_print_char(port, 0);
}

This assumes a bare metal, no thrills scenario. If you have an ASF project, though, it includes by default CMSIS, which contains all the definitions of all the registers in the microcontroller. Moreover, CMSIS suggests that of the 32 ports of the ITM one should use Port #0 for printf()-style strings sent to the debugger, and Port #31 for RTOS relevant messages. Moreover, it defines a set of standard functions for accessing the ITM Port #0, on of which is ITM_SendChar():

__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
{
  if ((ITM->TCR & ITM_TCR_ITMENA_Msk) && /* ITM enabled */
      (ITM->TER & (1UL << 0)        ))   /* ITM Port #0 enabled */
  {
    while (ITM->PORT[0].u32 == 0);
    ITM->PORT[0].u8 = (uint8_t) ch;
  }
  return (ch);
}

The checks for ITM Enable and Port #0 enable are already there, so they are not required anymore again in SWO_print_string, so the whole code needed now becomes:

void SWO_print_string(const char *s);

void SWO_print_string(const char *s )
{
 while (*s) ITM_SendChar(*s++);
 ITM_SendChar(0);
}

With the code added, the whole program looks like this:

#include <asf.h>
#include <stdio.h>

void SWO_print_string(const char *s);

void SWO_print_string(const char *s )
{
 while (*s) ITM_SendChar(*s++);
 ITM_SendChar(0);
}


volatile uint32_t sTicks = 0;

void SysTick_Handler(void)
{
 if(sTicks <10)
 {
  sTicks++;
 }
 else
 {
  SWO_print_string("Interrupt one second.");
  sTicks = 0;
 }
}


int main (void)
{
 uint32_t return_value = 1u, idx;
 
 /* Insert system clock initialization code here (sysclk_init()). */
 sysclk_init();
 board_init();

 // Configure SysTick_handler for 100ms rate
 if((return_value = SysTick_Config(SystemCoreClock / 10)) == 0)
 {
  SWO_print_string("Clock configured successfully.");
 }
 else
 {
  SWO_print_string("Clock NOT configured successfully!!!");
 }

 /* Insert application code here, after the board has been initialized. */
 for(;;)
 {
  //give the loop something to do
  for(idx=0;idx<100000000;idx++)
  {
   nop(); //just waste time
  };
  SWO_print_string("In the loop.");
 }
}

I am pleased to report that the output now works in the Percepio Trace window, as expected. On the J-Link Ultra, that is. On Atmel-ICE it doesn't work, for love, nor money. Does anyone know why, by any chance? Atmel-ICE documentation claims that it is capable of receiving SWO information, but neither the Percepio Trace, nor the Control-flow Trace work at all.

Also, I am curious in knowing why the printf()-style implementation did not get displayed in the Percepio Trace window, when J-Link SWO Viewer did see them? The source for my implementation relies on overriding the _write() function and is found here:

http://blog.atollic.com/cortex-m-debugging-printf-redirection-to-a-debugger-console-using-swv/itm-part-1

There is another option which overrides puts() instead of _write(), which I haven't tried, here:

https://www.doulos.com/knowhow/arm/Retargetting_a_C_library_function/

I believe it would be quite useful to have a working printf(), with at least integer parsing in hex and decimal, which would be the next step, so I am curious of hearing from others if they have any ideas. The information on the web seems to suggest the first solution should work, i.e. the one with providing a _write() function, but in our case it doesn't. Any thoughts would be very useful.

I tried SWD interface frequencies in the Project Properties -> Tool: 2 MHz (it defaults to that), 1 MHz, 500 kHz, 250 kHz, 100 kHz, 20 kHz, with matching frequencies for Percepio Trace Frequency Setting, no joy.

It's a good point with the printf(), as the Percepio Trace solution seems to favour the sending of '\0' at the end, presumably as a terminating character. So I tried it after changing the _write function thus:

int _write(int file, char *ptr, int len)
{
 int i=0;

 for(i=0 ; i<len ; i++)
 {
  ITM_SendChar((*ptr++));
 }
 ITM_SendChar(0);
 return len;
}

and, what do you know, it works! It shows the message nicely in Percepio Trace, and J-Link SWO Viewer does not seem too bothered by it, showing the message correctly. This leads to my concluding that for a good Percepio Trace display we need a terminating '\0' to be sent to the ITM for its being displayed in the window. That is marvellous, thanks a lot for your help!

For those who only have an Atmel-ICE, though, this does not seem to be working. Any suggestions what I can try to make Atmel-ICE work?

Upon further reading, it appears to me as though the value in the TPI->ACPR register should be written by the Debugger upon starting Trace with a value of (CPU_CORE_FREQUENCY / SWO_DESIRED_SPEED) - 1. The setting in the Percepio Trace Setting (Frequency) should be SWO_DESIRED_SPEED, and I am wondering then where does the Atmel-ICE get its CPU_CORE_FREQUENCY from? I can understand J-Link doing the RAM thing you mentioned to get CPU_CORE_FREQUENCY, but how about Atmel-ICE? Because for sure the register TPI->ACPR does not get written with a value other than 0, no matter what Frequency I put in the Percepio Trace Settings. And a value of 0 in TPI->ACPR means that (CPU_CORE_FREQUENCY / SWO_DESIRED_SPEED) would be equal to 1. J-Link, when left to its own and works, puts 1 in the TPI->ACPR register, meaning that (CPU_CORE_FREQUENCY / SWO_DESIRED_SPEED) would be equal to 2, which makes sense as the SWO frequency in that case is 42.666 MHz, roughly half that of the processor, which is 84 MHz. If so, again, how to tell Atmel-ICE the processor speed?

Again, this may all be just silly, and I got it all wrong, but it would be useful to know.

It is probably worth summarising my findings in regards to making use of the ITM debugging facility. Again, it is very easy to use Atmel Studio 7 and the ASF Framework, in which case all register definitions are available.

The first solution to using the ITM is the one where it allows you to print message to the Port #0, the default port for sending strings for debugging. the following needs defining:

void SWO_print_string(const char *s);

void SWO_print_string(const char *s)
{
    while (*s) ITM_SendChar(*s++);
    ITM_SendChar(0);
}

This is by far the easiest option, which uses the CMSIS-defined function ITM_SendChar(), which write directly to the Port #0 of the ITM. Using it is then just as simple as:

SWO_print_string("All is well thus far.");

The second, more complex option, is to allow the strings to be sent to any of the ITM ports, from Port #0 to Port #31. For that we need a bit more code, and the ability to pass the Port # to the function writing the character. As ITM_SendChar() only writes to Port#0, we need to write our own equivalent option including the Port #. The printing function also needs updating:

void SWO_print_char(int port, char c);
void SWO_print_string(int port, const char *s);

void SWO_print_char(int port, char c)
{
    while ((ITM->PORT[port].u8 & 1) == 0);
    ITM->PORT[port].u8 = c;
}

void SWO_print_string(int port, const char *s)
{
    if ((ITM->TCR & 1) == 0) return;
    if ((ITM->TER & 1) == 0) return;
    while (*s) SWO_print_char(port, *s++);
    SWO_print_char(port, 0);
}

Now we can print to whatever port we want, and Percepio Trace, I find, will display that message and will also be showing which port it is sent at. Handy.

The third option is to use the tried and tested printf() solution, redirected to the Port #0 of the ITM. In doing so, we can also enable the printf()-style parameter passing, and we can display various variables' values. The caveat is that, like any printf()-style function, it is buffered, meaning that usually we need to terminate any string we display with a "\n", Carriage Return, otherwise nothing will be displayed in the Percepio Trace window for quite a while, until the buffer is full and then a huge amount of data will be sent to the Percepio Trace. In order to do this, though, we need to define two functions, _write() and _read(), which are the low-level functions that printf() calls to do the actual displaying of the formatted and processed string. Here's how we can do that:

#include <stdio.h>

int _write(int file, char *ptr, int len);
int _read(int file, char *ptr, int len);

int _write(int file, char *ptr, int len)
{
 int i=0;

 for(i=0 ; i<len ; i++)
 {
  ITM_SendChar(*ptr++);
 }
 ITM_SendChar(0);
 
 return len;
}

int _read(int file, char *ptr, int len)
{
 //dummy, does nothing, just to avoid linker error
 return len;
}

After that one can use printf() with normal parameters as one would on any other system, and all will be displayed in the Percepio Trace window:

printf("The value of idx is %d.\n", idx);

Again, if you don't place the Carriage Return to terminate the string, you might not see much I Percepio Trace. Also, the Carriage Return makes Percepio Trace not to look too well, due to the extra end of line. Here then comes the fourth solution.

What if I wanted to have a function that does not require my having to end the strings in the printf() with "\n", i.e. is there another way to flush the buffer? Apparently there is, and the function is fflush() and is called as fflush(stdout), which is what the ITM is in our case. Now we can pass fancy messages without worrying about the Carriage Returns. Here's the trick:

#include <stdio.h>
#include <stdarg.h>

int _write(int file, char *ptr, int len);
int _read(int file, char *ptr, int len);
_ATTRIBUTE ((__format__ (__printf__, 1, 2))) int myprintf(const char *__restrict format, ...);

int _write(int file, char *ptr, int len)
{
 int i=0;

 for(i=0 ; i<len ; i++)
 {
  ITM_SendChar(*ptr++);
 }
 ITM_SendChar(0);
 
 return len;
}

int _read(int file, char *ptr, int len)
{
 //dummy, does nothing, just to avoid linker error
 return len;
}

_ATTRIBUTE ((__format__ (__printf__, 1, 2))) int myprintf(const char *__restrict format, ...)
{
 __VALIST args;
 int return_value;

 va_start(args, format);
 
 return_value = vprintf(format, args);
 fflush(stdout);
 
 va_end(args);
 return return_value;
}

In this way I produced my own printf()-style function, myprintf(), which I don't have to terminate with a Carriage Return, as it flushes the stdout buffer after each call. Now all I have to do is:

myprintf("The value of idx is %d.", idx);

So here are four ways in which to instrument your code to get it work with Percepio Trace. Hope it helps.

By Jove, you are right. Where has Percepio Trace gone?