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.

Richiedi informazioni per questo prodotto

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

Download   Ozone - The J-link Debugger for Windows, installer, 32bit

Download   J-Link Software and Documentation Pack for Windows

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

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


 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.


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 LinesOn 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


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.


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. load statistics.

trace-tutorial-5.png Trace tutorial

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:

  1. SEGGER Cortex-M Trace Reference Board: The main project with device support for the Cortex-M Trace Reference Board
  2. SEGGER emPower Reference Board: The main project with device support for the emPower Reference Board
  3. Application: The trace demo sample application
  4. 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)

  • Trace and streaming probe
  • Real-time streaming of events and system ticks
  • Tune your application with live profiling
  • Satisfy regulatory requirements with instruction-level code coverage
  • Isolate and Identify hard-to-find code defects with unlimited trace
  • Full J-Link debug functionality