Graphical debugger with J-Link/J-Trace integration

The most used window is the Source Code Editor. In Debugging Mode it shows you where your application is currently halted. You can set Breakpoints in the Code on lines which are marked with a small blue Arrow by setting the cursor into the line and selecting Debug → Toggle Breakpoint (F9) or clicking on the arrow. A black dot marks lines on which a breakpoint is set and when the Application reaches this line it halts execution. You can directly get information about the symbols in your application, by moving your mouse over them. The mouse-hover box shows you the value of the symbol. The right-click context menu provides some more useful actions, like running to the current cursor position or setting the next execution statement to the current cursor.

The Debug Terminal displays output from the target application, for example done with printf and RTT. The output can be formatted by the application with ANSI Escape Sequences to for example change text and background color.

Embedded Studio includes support for output via RTT, SWO, DCC, and Semihosting.
With Semihosting the standard I/O operations are supported, enhanced by host-based formatting for smallest embedded applications.

Embedded Studio includes different Watch windows used to monitor variables. The Locals window displays the local variables and parameters of the current function. The Globals window displays the global variables of the application. The Autos window displays the variables which are important in the current context. To the Watches window you can add any Variable and display them regardless of the current function (if they are available).

Embedded Studio features type awareness for C++ template container types. Containers, such as std::list, std::map, and std::array, as well as custom container classes, can be displayed in easy to understand human-readable lists instead of in their internal implementation form.
Type interpretation files for container types in the C++ standard library are included in Embedded Studio (e.g. $(StudioDir)/bin/libc++.xml). Custom container interpretation can be easily constructed in a structured XML file.
More information: https://studio.segger.com/ide_type_interpretation_file_format.htm

The Threads window allows OS aware debugging. When you are debugging a (real time) OS like → embOS, the Threads window can show the running Tasks / Threads of your Application and their status. With a double-click on a Thread you can switch to it to examine its Registers and Call Stack. To be able to show Thread Information Embedded Studio requires a Threads Script for your OS. This can be part of your Project and set in the Project Properties. If you do not already have a script for your OS it can be easily written in JavaScript. FreeRTOS and embOS are currently supported.

The Registers window shows the CPU Registers as well as Memory Mapped Registers (MMRs, Peripheral Registers). You can select which Register Groups should be shown and also hide single Registers. Registers can be shown in different numerical formats or extended to their bit-fields. You can also modify Register Values directly in the Registers window. When stepping through your Application changed Register Values are highlighted for easy identification.
Embedded Studio allows you to show up to 4 Registers windows, which can be used to view different Register Groups in different windows.

The Call Stack window shows in which function the application is currently halted and its callers up to the top level. You can double-click on each caller to examine the exact location of the call and get additional information about the calling function, like its local variables. If you are debugging with OS awareness, the Call Stack window will show the call stack of the selected task.

The Embedded Studio debugger features code breakpoints on instructions, functions, and source lines, as well as data breakpoints upon access of variables in memory.
Additionally breakpoints can be set with simple C-like expressions. For example, the expression x == 4 will breakpoint when x is accessed and its value is 4. The operators <, >=, >, >=, ==, and != can be used similarly.
You can also use the operator '&' to mask the value you wish to break on, for example, (x & 1) == 1 will breakpoint when x is accessed and has an odd value, or you use the operator '&&' to combine comparisons. For example (x >= 2) && (x <= 14) will breakpoint when x is accessed and its value is between 2 and 14. You can specify an arbitrary memory range using an array cast expression. For example, (char[256])(0x1000) will breakpoint when the memory region 0x1000–0x10FF is accessed.
You can specify an inverse memory range using the ! operator. For example !(char[256])(0x1000) will breakpoint when memory outside the range 0x1000–0x10FF is accessed.