- Small-footprint (small as 2KB, automatic scaling)
- Fast execution (sub microsecond context switch)
- Supports all popular processors and tools (see below)
- TraceX system analysis support
- Advanced Technology:
- Preemption-Threshold™
- Event Chaining™
- Performance Metrics
- Execution Profiling
- Run-time and Static Stack Analysis
- Multicore Support (SMP and AMP)
- Downloadable Application Modules
- Memory Protection for Downloadable Application Modules
- Extensive ThreadX ecosystem
- Safety Certifications (DO-178B, FDA510(k), IEC61508, etc)
- Deployed in over 1,000,000,000 devices
- Full Source Code
- Royalty-Free
- A2P
- AMD G-Series
- ARC
- ARM/Thumb
- AVR32
- BlackFin
- CEVA-TeakLite-III
- ColdFire/68K
- Freescale i.MX Family
- Freescale Kinetis
- Hitachi H8/300H
- Leon3
- Luminary Micro’s Stellaris®
- M-CORE
- MicroBlaze
- Microchip PIC24/dsPIC
- Microchip PIC32
- MIPS
- Nios II
- Power Architecture
- Renesas RX
- Renesas SH
- Renesas V8xx
- SHARC
- StarCore
- STMicroelectronics STM32
- StrongARM
- TMS320C54x
- TMS320C6x
- Win32
- x86/x386
- XScale
- Xtensa/Diamond
Lauterbach
Lauterbach's TRACE32 Debugging for ThreadX
RTOS Debugger for ThreadX
- Real time, non-intrusive display of ThreadX system resources
- ThreadX specific display of analyzer listing
- Statistic evaluation and graphic display of thread run times
- Thread related evaluation of function run times
- Statistic evaluation and graphic display of thread states
- Thread stack coverage
- Thread Context display
- PRACTICE functions for OS data
The TRACE32 System includes a configurable multitask debugger to provide symbolic debugging in real time operating systems. Our software package contains a ready-to-run configuration for the ThreadX Real Time Kernel from Express Logic.
In close cooperation with Express Logic, we built a high sophisticated ThreadX awareness, which enables you to do a most effective debugging with the TRACE32 systems on targets running ThreadX.
Multitask Debugging on TRACE32 with ThreadX
Real time, non-intrusive display of ThreadX system resources
The TRACE32 multitask debugger for ThreadX provides display functions for all ThreadX resources. The system resources threads, application timers, queues, semaphores, events, block pools and byte pools can be displayed. In addition, by using the emulators dual-port memory, the display of all these regions can be viewed non-intrusively in real time. The tables are updated permanently (“On The Fly”), without affecting the application at all.
Thread Status list window and detailed window of one specific thread:
Detailed window of a queue and a semaphore
ThreadX specific display of analyzer listing
The data recorded in the analyzer can be displayed and interpreted specific to the operating system. The thread switches can be displayed symbolically.
Analyzer listing, display of task switches and source lines
Statistic evaluation and graphic display of thread run times
The analyzer can calculate statistic tables of thread run times and thread switches. A graphical diagram shows which thread was active at a specific time, giving a clear view of the behaviour of the system.
Statistics and flow of tasks
Thread related evaluation of function run times
The statistic and graphic evaluation of function calls and function run times can be done dependant to the actual running thread. This is necessary, if different threads call one single function at the same time, or if a thread switch occurs in between the function.
Statistics and flow of thread dependent funtion run times
Statistic evaluation and graphic display of thread states
These tabular and graphical analyses of the status of threads show the various states (i.e. running, ready, waiting, suspended and undefined) and times each thread spent in each state. A graphical view of the data can help to highlight prioritisation problems, critical paths etc.
Statistics and flow of thread states
Thread Stack Coverage
In real time systems it is quite important to know, how much stack space each thread consumes. For this purpose a special window shows the current and the maximum usage of each seperate thread.
Thread stack coverage window
Thread Context Display
The TRACE32 Multitask debugger provides an easy way to to switch the current displayed context to another thread. Normally all register related windows (e.g. listing at current PC, local variables or function call stack) are displayed related to the actual context (i.e. current executed thread). You can switch to the context of another thread to see all this information at the time this thread was scheduled.
PRACTICE functions for OS data
The support includes extended PRACTICE functions for ThreadX specific data. E.g. the function “TASK.CONFIG (magic)” returns the address of the so called magic value, which corresponds to the id of the current executed thread.
ThreadX related pull-down menu
Because the menu bar of the TRACE32 user interface can be fully customized, you can create a new pull down menu, including operating system specific commands. We deliver ThreadX support with an example for such specific menues, which provides fast access to the ThreadX features.
TRACE32 with ThreadX menu
Embedded World 2012
February 28 - March 1, 2012
Nuremberg, Germany
