J-Trace PRO—Analyze, Verify, and Profile your Code
J-Trace PRO is defining a new standard for trace probes. It enables continuous streaming trace, lifting the limitations by internal buffers and slow data transmission to give you all the insights you need to develop and optimize your code.
J-Trace PRO can capture complete traces over long periods—thereby enabling the recording of infrequent, hard-to-reproduce bugs. This is particularly helpful when the program flow ‘runs off the rails’ and stops in a fault state.
It also supports extended trace features, such as code coverage (so engineers have visibility over which parts of the application code have been executed) and execution profiling (providing visibility as to which instructions have been executed and how often—so hotspots can be addressed and optimization opportunities identified).
Tutorial Project
The Ozone J-Trace PRO Tutorial Project serves as a starting point to test the J-Trace PRO streaming trace and live analysis capabilities, and demonstrates how developers can get the most advanced analysis of their system within 15 minutes.
The Tutorial Project starts with a simple application running on the target hardware, demonstrating the trace features without any special code or configuration. More advanced examples, including system init and the use of embOS are part of the project too, and can be analyzed with J-Trace PRO as well. It includes the pre-built applications, the Ozone projects, and an Embedded Studio project to modify and re-build the application.
Download Ozone J-Trace PRO Tutorial Project
Target Hardware
The tutorial project can be used with the SEGGER Reference Boards. The Tutorial Walkthrough is written for the Cortex-M Trace Reference Board. The same instructions apply for the emPower Board with the according files.
Cortex-M Trace Reference Board
- ST STM32F407VE
- ARM Cortex-M4F
- External debug header with trace pins
- Test points for trace signals
emPower Reference Board
- NXP MK66FN2M0VMD18
- ARM Cortex-M4F
- External debug header with trace pins
- More information
Tutorial Walkthrough
1. Download the tutorial project and make sure the J-Link Software and the latest Ozone are installed.
2. Extract the project into any destination directory on your computer, C:\Tutorial\Tracing\.
3. Connect the J-Trace PRO with your computer and the target board, and power the board.
4. Open Start\SEGGER_CortexM_Trace_Reference_Board.jdebug from the project directory with Ozone.
5. Open the Code Profile Window and the Instruction Trace Window. (View -> Code Profile> and View -> Instruction Trace)
6. Set a breakpoint at BSP_SetLED(0); in main() in TraceDemo.c.
7. Start the debug session. (Debug -> Start Debugging)
Ozone starts and loads the pre-built executable for your Cortex-M Trace Reference Board. The application is loaded into your Cortex-M Trace Reference Board, it starts and runs to main.
8. Continue to run to your breakpoint. (Debug -> Continue)
Ozone breaks after returning from BSP_Init().
The Instruction Trace Window shows what has been executed up to this point. The most recent instructions are at the bottom. Instructions are grouped by source line and corresponding function. Collapsing all blocks shows which functions have been called and to which functions the application returned.
When all blocks are expanded, you can navigate through the instructions to follow the execution in the Source Viewer and Disassembly Window and see what has exactly happened from the start at main until the breakpoint was hit.
9. Continue the execution again. (Debug -> Continue)
The application runs and the LEDs flash. The left column in the Source Viewer and the Disassembly Window displays the code coverage of the application to show which source lines and instructions have been executed. Source lines in the Source Viewer can be expanded to show which instructions each source line generated.
The code coverage information is colored in three different levels
| On Source Lines | On Instructions |
|---|---|
| All instructions executed | Instruction fully executed (if conditional, condition met and not met) |
| Conditional instruction never executed (condition always not met) | |
| Not all instructions executed | Conditional instruction not fully executed (condition always met) |
| Code never reached | Instruction never fetched |
10. Show Code Profile counters in Source Viewer. (Right-Click in Source Viewer -> Show Execution Counters)
In addition to the code coverage marker, the left column can show the execution count of source lines and instructions. The counters are updated from the trace stream, while the application is running. Hover the mouse over a counter to get the fetch and not-executed count, and the CPU load of this line in a tooltip.
11. Open the Code Profile Window. (View -> Code Profile)
The Code Profile Window displays the code coverage and profiling information by function. It allows sorting by load or coverage and filtering functions to not count them in the load statistics.
12. Export trace data into a report. (Right-Click in Code Profile Window -> Generate Report)
The information from the Code Profile Window can be exported into a report which can be used for verification processes.
The Tutorial Project includes all sources to recompile the application in an Embedded Studio project.
To alter the project, open Start\J-Trace_PRO_CortexM_Tutorial.emProject with Embedded Studio.
The solution consists of four projects:
- SEGGER Cortex-M Trace Reference Board: The main project with device support for the Cortex-M Trace Reference Board
- SEGGER emPower Reference Board: The main project with device support for the emPower Reference Board
- Application: The trace demo sample application
- Common: Shared modules for both boards
Modifications should be done to the Application project. You can change OS_TraceDemo.c, include TraceDemo.c, which runs without an OS, or add your own application file.
When all changes are done, recompile the project (Build -> Build Solution), which creates the application for both reference boards. If the Ozone project is still opened, it will prompt to reload the application file which has just changed. If Ozone is not started, start it and load Start\SEGGER_CortexM_Trace_Reference_Board.jdebug.
To test the tracing and analysis features on the emPower board, open Start\SEGGER_emPower_Reference_Board.jdebug instead.
Supported IDEs
Full J-Link/J-Trace Support
The following table lists the IDEs fully supporting J-Link/J-Trace and the additional features of J-Link/J-Trace, which can be used with them.
All following IDEs have debug support, including: Download to flash and RAM, memory read/write, CPU register read/write, run control (go, step, halt), software breakpoints in RAM, hardware breakpoints in flash memory, and use of Unlimited Flash Breakpoints.
J-Trace Media
J-Trace PRO - Get ready in less than 10 minutes (9:38)
J-Trace PRO - Live Profiling and Code Coverage (1:55)
J-Trace Model Overview
J-Trace FAQs
What is the advantage of using the J-Trace PRO over other trace probes?
One of the biggest advantages the streaming trace capability. With streaming trace you get the ability to do continuous live trace analysis to be able to debug even the most complex problems. In addition to that, J-Trace PRO can be used with most Cortex-M devices out-of-the-box and does not require complex configuration.
What are the other differences to the older J-Trace for Cortex-M?
J-Trace PRO can now work with trace clocks of up to 150 MHz (300 MHz CPU clock). It is equipped with Gigabit Ethernet for streaming trace and remote debugging. The debug interface speed has doubled. J-Trace PRO includes more options for configuration and troubleshooting, made easily available through the integrated web server.
Can I use the J-Trace PRO as a debug probe?
Yes. The J-Trace PRO includes all capabilities of the J-Link debug probes and comes with all licenses, such as for unlimited flash breakpoints. It can be used with the J-Link Software and any tool that supports the J-Link.
Can the J-Trace PRO be used with any IDE?
Yes, the J-Trace PRO can be used with all common IDEs, just like any J-Link debug probe.
Can any IDE be used for tracing as well?
Unfortunately most IDE vendors do not offer trace analysis features or only to a limited degree.
What can I use for tracing and analysis?
We recommend using the graphical stand-alone debugger Ozone. It supports all capabilities of the J-Trace PRO and compliments them with advanced analysis features. Ozone can be used compiler independent, with output of any IDE or toolchain. Ozone can be used completely free of charge with a J-Trace PRO, even for commercial use.
What do I need to do to trace with a J-Trace PRO?
Usually just connect to your target device and start debugging. J-Trace PRO is designed to simply work. You can get up and running in less than 10 minutes.
Where can I find trace related troubleshooting information?
Tracing is a very hardware dependent debug technique and some target hardware modifications or designs can cause issues when trying to set up the trace debug interface. To give our customers a simple to use troubleshooting platform with the most asked questions answered we have created the following setup page: Setting up Trace
Should any other question arise you can contact us at: supportsegger.com
Are there any trace example projects that I can use for orientation?
Yes, every J-Trace PRO gets shipped with a Cortex-M Trace Reference Board. An example project is part of the J-Trace tutorial.
We also created a list of tested devices that each come with an example project that runs out-of-the-box with a J-Trace PRO and Ozone. The list is available here and is being updated constantly.
My device is not on the tested devices list, what can i do to get an example project for it?
As the market with trace capable MCUs is growing it is becoming harder to keep track of all devices. Should it happen that we do not have a trace example for your particular device feel free to contact us at supportsegger.com
Requirement for adding a new example project are:
- Must be supported by J-Link software: Overview of supported CPUs and Devices
- The target hardware must be publicly available and an evaluation board
- Trace pins must be physically connected to the trace debug interface