J-Trace PRO
Analyze, Verify, and Profile Your Code
- Real-time streaming trace at full System Clock
- Tune your application with live code 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
J-Trace PRO: The Leading Trace Solution
J-Trace PRO is an advanced debug probe that supports Arm's advanced tracing features of Arm Cortex cores. It can capture complete instruction traces over long periods of time—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.
In combination with our toolchain independent debug software Ozone and the extensive example project library, including the most popular target devices, our J-Trace PRO user gets the best possible trace experience.
Features
J-Trace PRO offers an extensive featureset fulfilling any requirement a J-Trace PRO user might have. The most prominent features that make this trace probe the leading trace probe are as follows:
- Streaming Trace
- Unlimited Trace Buffer
- Trace support for Cortex-A/R/M target devices
- Live Code Coverage
- Live Code profiling
- Power Trace of target device's current consumption
- Cross Platform Support (Win/Mac/Linux)
- Supported in most popular IDEs
- Free stand alone debugger Ozone can be used with any tool chain to enable tracing
- Unlimited Flash Breakpoints
- Trace Reference Board included for quick and easy first steps
- Fanless design
Streaming Trace
One of J-Trace PRO's main features is the so called Streaming Trace. With this feature J-Trace PRO can process instruction trace data sent from the target device in real-time fashion using trace pins. That way the user knows exactly what the target device is and was doing at any point in time. This does not only enable a deep insight in any application running on the target device but offers also additional powerful debug strategies that can be applied.
Real Time Profiling
Real Time Profiling provides visibility as to which instructions have been executed and how often—so hotspots in an application can be addressed and optimization opportunities identified. These profiles can later be exported using e.g. Ozone debugger for documentation and analysis purposes.
Real Time Code Coverage
Real Time Code Coverage helps engineers have visibility over which parts of the application code have been executed.
Get Started Easily
J-Trace PRO has been designed to work out-of-the-box with most trace capable target devices. An extensive list with tested target devices gets updated regularly with the latest target device releases. In all other cases J-Trace PRO offers additional features that can make any trace setup possible. It has never been easier to get a trace setup up and running.
Trace Reference Boards
Every J-Trace PRO package comes with a Cortex-M Trace Reference Board included. Other Trace Reference Boards based on other target devices are also available. The Trace Reference Boards are perfect for quick and simple trace setups and can be used as reference for custom board designs.
Model Comparison
Hardware features like Ethernet interface, USB full- / high-speed interface, etc. are J-Trace model specific features which can not be updated or changed by software updates. For more information please visit our J-Trace PRO overview webpage.
| Feature | J-Trace PRO Cortex-M | J-Trace PRO Cortex |
|---|---|---|
| USB | 3.0 (SuperSpeed) | 3.0 (SuperSpeed) |
| 10/100/1000 Ethernet | ||
| JTAG interface | ||
| SWD interface | ||
| SWO interface | ||
| Unlimited Streaming Trace + Live Analysis | ||
| Cortex-M ETM Trace | ||
| Cortex-A ETM Trace | ||
| Cortex-A PTM Trace | ||
| Cortex-R ETM Trace | ||
| Streaming bandwidth USB | 1.2 Gbit/s | 1.2 Gbit/s |
| Streaming bandwidth Ethernet | 720 Mbit/s | 720 Mbit/s |
| Max. TPIU frequency | 300 MHz | 300 MHz |
| Max. trace clock frequency | 150 MHz | 150 MHz |
| Additional information | More | More |
Supported
Not Supported
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.
Note: To get started with tracing on your own hardware after finishing this tutorial please visit: Tested Devices for tracing with J-Trace PRO
Additional setup information can be found here: J-Trace PRO - Setting up Trace
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.
3. Connect the J-Trace PRO with your computer and the target board, and power the board.
4. Open 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_Init; in main() in OS_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 OS_InitHW().
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. 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 -> 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 live 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. 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. In the example screenshot below OS_Idle() is deselected from the load calculation as the application spends over 99% of its time in that function.
12. Export trace data into a report. (Right-Click in Code Profile Window -> Export...)
The information from the Code Profile Window can be exported into a report with different formatting 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 J-Trace_PRO_CortexM_Tutorial.emProject with Embedded Studio.
The solution consists of one project where the SEGGER Cortex-M Trace Reference Board runs at maximum CPU and Trace clock speed and toggles two of the three available LEDs.
Modifications should be done to the Application project. You can change OS_TraceDemo.c or add your own application file.
When all changes are done, recompile the project (Build -> Build Solution), which creates the application for the reference board. 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 SEGGER_CortexM_Trace_Reference_Board.jdebug.
J-Trace Model Overview
J-Trace PRO Cortex
J-Trace PRO Cortex-M
FAQ
What is the advantage of using the J-Trace PRO over other trace probes?
A: 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?
A: 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?
A: 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?
A: 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?
A: Unfortunately most IDE vendors do not offer trace analysis features or only to a limited degree.
What can I use for tracing and analysis?
A: 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?
A: 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?
A: 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: support@segger.com
Are there any trace example projects that I can use for orientation?
A: 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?
A: 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 support@segger.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