• Mainscreen

High-Performance Interactive User Interface

All commands can be entered by the keyboard, the function keys or with the mouse.

Universal Window System

Windows of any size can be created and positioned anywhere on the screen. In each window there is a horizontal and a vertical scroll bar. Up to 128 windows may be open simultaneously. Windows may either be static (contents fixed), dynamic (contents variable) or temporary. Dynamic windows are updated at a rate of up to 300 times per second. Workstation based software uses the same graphic elements like the host operation system.

Window Configuration Save and Restore Facility

Each window configuration that the user designs can be saved for later reuse. Several user predefined configurations can easily be selected from the keyboard by switching the window pages.

5 Screen Areas

For interactive operation, the screen is split into several areas:

  • State Line
  • Window Area
  • Command Line
  • Message Line
  • Soft Keys (function keys)


Special Test Language for Automatic Test and Batch

TRACE32 has it′s own special BASIC-like meta-language called PRACTICE II which is a superset of it′s fundamental commands. Complete programs may be constructed using PRACTICE II for automatic testing or for the construction of command macros. All aspects of the systems may be controlled/programmed via the PRACTICE language


All important characteristics of the system can be accessed by the PRACTICE language functions. In particular the PRACTICE program can be used to automatically enter target data

Practice Command Words

  • ( block )
  • IF, ELSE


Structured Programs

PRACTICE is a highly structured language. Local and global variables may be used. One module (file) may call another.

Practice Debugger

A powerful Debugger for debugging Practice Programs is included.


  • Plist2
    Practice Debugger
  • Pmacro
    Practice Macro and Nesting Display

Low Level Debugger Functions

Especially for testing of Prototypes, Trace32 serve a lot of Functions and Commands.


A built in Page Assembler can be used for create small Test-Code directly in the Target. The Page Assembler is used on the same way as a editor writes in a Document. The Compile Button generates the Assembler-Code to the Target.

Memory-Test an CPU-Cycle Generation

Different Commands are available for create Patterns to the Memory or for Memory Test's. The Command can generate exactly defined CPU-Cycles in endless loops for measurement with Oscilloscopes or Logic-Analyzers in the Target.

Peripheral Handling

The complex Peripheral Parts of the Device is handled by a powerful Peripheral Window. The Window shows the Status of the Peripheral content and refresh the Data continuously. The Window is used for show and change the Peripheral on Bit Level. The Window is defined with a special Language and the Engineer can create additional Windows (e.g. for FPGA) himself.


Trace32 supports programming of parallel and serial Flash devices in different technology (NOR and NAND).



  • Page Asm
  • Data List Asm2
    Assembler Debugging (compiled from Page-Assembler)
  • ASM Source Debugging
    Assembler Source Level Debugging
  • Ramtest
    RAM-Test or RAM-Pattern generation
  • Per
    Peripheral Window

Very Powerful and fast High-Level Language Debugger

C, C++, JAVA, PASCAL, PL/M, ADA or MODULA2 Debugger with very flexible handling of Variables. Every Object in the Window can be change by simple Mouse-Click. Show quickly Values by click to the Object in the Source-Window. Create multiple additional View Windows with complex Objects and Terms.

Special Windows for Table or Linked List's. Graphic Display of Arrays. Scaled Variable View (e.g. the Value of a AD-Converter can convert and scaled for Display as a mVolt Value).
Free Format of Displayed Objects.

Direct Functions for Debugging

Go to Read/Write Access on Object by a simple Mouse-Click. The Command-Parser supports 64Bit C Syntax. The Access to Struct's or C++ Object works on the same way as in the Language.

Multi-Core / Multi-Processor Debugging

Debugging support for Asymetrical [AMP] Multiprocessor and Symetric [SMP] Multi-Core / Multi-Processor Targets.

Powerful Symbol Management

A important part of the Debugger is the Symbol-Browser. With the Browser, every Object of a Project can be access on a easy and quickly way. The Command-Line Parser use the Symbol Browser in the background for filling the Parameter automatically.


Large Projects can be separated with free defined Group's. Every Group have a Color and can optional remove form the Symbol-Database (e.g. Kernel ).


The Debugger loads the Compiler Debugging Format directly. Trace32 supports all popular Compiler Formats like ELF, COFF, UBROF, ROF, OMF, COSMIC ....

  • D L Quickview
    Source Listing, with quickview the content of a Variable (Table with Pointer)
  • Var Frame
    Stack-Frame Window.
    MutexTask has called SharedCode()
    SharedCode() has called sieve().
    All local Variable of each Functions are displayed and can change with the Mouse.
  • Var View
    Variable Display.
    Very flexible Window for create free calculation with Variables.
  • Var View 1
    Display of a Linked-List with some Struct-Pointers.
    Optional enabled is the display of the Type Information.
  • Var INFO
    Symbol Database Information for a selected Struct
  • Var Draw
    The Content of a Array of double, is displayed as Grafic
  • Y Browse 1
    Symbol Browser, for search and select any Objects
  • Y Browse Struct
    Symbol Browser for Structs
  • Menu Symbol
    Multiple accesses are available to the Symbol Database

Code- and Data-TRACE

Lauterbach offers different Trace Systems for On- and Off-Chip Trace. Bus-Trace, Parallel and Serial Flow-Trace Systems for the most Devices on the Marked. The Trace-Hardware supports the highest Speed and have a automatic Adaptation to the Target Timing.
The Universal Trace-Memory can be scale from 128MByte up to 4GByte or, is used as FIFO for endless Streaming to Host (for slow-Speed Devices only).

Powerful Software

The traced Data can be analyze in very different and powerful way. The Focus to the Traced-Data is define from Assembler-Level up to Task-Level in Listing- or Chart-Windows. Free placed markers, directly in the source, can be used for create Time-Measuring-Points (e.g. for Loop- or Code-Reapeat/Runtime analyzing).This measurement, include the placement of the Markers, is done after the Code has traced.


In the past it was necessary to spend a lot of time analyzing the trace listing in order to find out which instructions, data or system states had caused malfunctioning of the target system.

Now Trace-based Debugging - called "CTS" - allows recreating the state of the target system at a selected point based on the information sampled in the trace buffer. From this starting point the program steps previously recorded in real-time in the trace memory can be debugged again in the TRACE32 PowerView.

Statistic Functions

A lot of Functions are available for create Statistics over the traced-Code or Data. Powerful Chart and Draw Windows are helpful for analyze Code-Timing or Data-Flow.


All Trace-Systems are time correlated to the other. Is a Timing-, Logic- or Protocol- Aanalyzer attached, then the Trace Memory of each System is time-correlated. A Mouse click in a Trace-Data-Window will positioned all other Windows to the same Time-Position.


RTOS Kernel Debugging

A very important part of a Debugger - Trace - System is the Kernel Awareness. With this Extension, the Tool can understand the Kernel activity. The Lauterbach Kernel-Extension have the advantage, that it not influence the Target in any way.

Dynamic Symbol relocating

In Target with MMU's and dynamic Memory allocation, the Kernel awareness supports the Debugger-MMU and relocate the Symbols to the location of the Process.

Kernel Status View

Different Windows shows the Status of the Kernel, and the Event- Objects. In the case, that the CPU-Device supports Live-View, the Kernel Awareness use the Trace32 Hardware for refresh this Windows up to 100 times per Second.

Task-Switch Information in the Trace-Data

Important for all nesting based Trace-Functions e.g. Function Statistic or Function Call-Tree or Call-Chart Windows, the Debugger must be see the Task Switches. This is a additional, important Job of the Kernel-Awareness Extension.




All Example on this Page are made with uC/OS-II on a Cortex-M Device.
The Kernel-Status-Windows are different for other Kernels.
  • Task List
    Kernel Status View
    Task List
  • Task Event
    Kernel Status View
    Event List
  • Task Event Queue
    Kernel Status View
  • Task Event Queue Data
    Kernel Status View
  • Trace Chart Task
    Trace Task Flow
  • Trace ProfileChart Task
    Trace Task Runtime Analyze as Profile
  • Trace Stat Task
    Trace Statistic Task-Run-Time
  • Trace Stat Tree  SemaTask1
    Trace Statistic Function Tree (for SemaTask 1)
  • Task Stack
    Kernel Status View
    Task Stack coverage


  • Trace List
    Trace Listing HLL Level Display
  • Trace List Mix
    Trace Listing HLL, Assembler and Data Flow
  • Trace Chart Func
    Function Call Chart Display
  • Trace Stat Func
    Function Call Runtime Statistic
  • Cts L 1
    Context Tracking Listing.
    Function-Nesting, with Parameter and Return-Value
  • Cts L 2
    Context Tracking Window, with opened Function Display
  • Cts L 3
    Context Tracking Listing with display down to Assembler-Level
  • Trace Stat ADistance-Alpha Alpha
    Time measurement with free placement Markers (single point or multipoint)
  • Trace Profile Distribution Data All
    The Result of a ADC is stored in a static Variable. All write access to this Variable is traced.
    The upper Window contains the Result-Distribution over the time.
    The lower Window display the Statistic Result of the same Data.
  • Trace Profile Distribution Data
    Same as above.
    But the upper Window ia zoomed in, the noise is displayed (bug in PCB design)
  • Trace Stat Tree
    Function Tree with Timing Statistic in a Traget with Kernel.

Code and Data Coverage

The Code and Data-Coverage is very helpful for test and check your Project. It gives the Answer to the Questions "Is my Code tested completely".

Depending of the Device, Trace32 offers C1- Code and Data Coverage.
The C1-Code Coverage is a Post-Trace Operation or, if it possible, a Hardware Based on the fly Operation. The C1-Technic generates a exact Database over the Executed Code and Read/Write Operation to the Memory.

Conditional Branch analyzing

Each conditional Branch has tree state:

  • taken
  • not taken
  • ok

Instruction-Statistic Coverage

The additional Instruction Statistic Coverage is a Trace-Post Analyzing and shows the count, and used Time for each HLL-Line.

It is helpful for Bug-Finding and Performance-Analyze.

  • C1-Module
    Code-Coverage on Module Level
  • C1 Func
    Code-Coverage on Function Level
  • C1 Code
    not exec = if() was newer true
    only exec = if() was only true
    ok = the code is complete executed, if() was true and not true.
  • C Data 1
    Data Coverage
  • C Data 2
    Data Coverage on a Table
  • Istat Module
    Instruction Statistic on Module Level
  • Istat Function
    Instruction Statistic on Function Level
  • Istat Code
    Instruction Statistic on Source Level

Energy optimization

Reducing energy consumption is becoming more and more important for the development of battery powered devices. Characteristics such as stand-by or operating time are crucial for the operation of equipment like mobile phones. Hence comprehensive measures for reducing energy consumption are an integral part of designing battery-powered devices.
Typical measures are:

  • The use of power-saving components with power-saving features
  • High level of integration
  • Variable CPU frequencies
  • Variable power supply
  • The use of microcontrollers with power-saving features, cache and on-chip memory

However, an optimal reduction of energy consumption can succeed only if the software that controls the equipment consistently exploits all possible power-saving features of the hardware. Energy is the product of current, voltage and time. Each of these parameters can be influenced by the control software.
Therefore software developers have to constantly attempt to find the optimal settings for these three parameters in the respective operating mode of the application. For instance you might ask yourself the following questions:

  • Is the microcontroller in the right power-saving mode ?
  • How do program changes affect power consumption?
  • Are there any in expected power peaks?

This kind of checks require a test set-up that measures, records and analyzes the program and data flow of the control software as well as current and voltage gradients. Additionally all these recordings have to be related to each other in a simple way.
At the Embedded World 2007, LAUTERBACH as the first manufacturer worldwide presents a powerful and easy-to-use solution addressing these issues.

    Configuration Pannel
    - 4 Volt Channel
    - 3 Current Channel
    - 3 hardware generated Power Channel (U * I)
    (up to two Analog Probe can used on a owerIntergrator-II)
  • PowerDrawTaskFunc
    Power consumption in the top Window (Start of the Application)
    Cursor correlation positioned Window shows the Task's - flow in the lower left Window
    and the Function - flow on the lower right Window.
  • ETA Statistic Tree
    Power consumption statistic in a Tree view.
  • ETA Statistic TreeChild
    Power consumption statistic in a selected Tree-Child.
  • ETA Profile Task
    Power consumption over the Task, showed as a Profile
  • ETA Statistic Task
    Power consumption statistic over all Tasks
  • ETA Profile Group
    Power consumption over free defined Groups.
    In this Example Groups reflects the Code for Kernel, Application and HAL Interface.
  • Overview
    Draw View for Current I and Power U * I


coming soon



coming soon