Home / Products / PLS / Universal Debug Engine (UDE)

PLSProducts

Universal Debug Engine (UDE)

Name: Universal Debug Engine (UDE)
Brand: PLS

Part no. / ID: UDE

UDEMulticoreAURIX

All PLS products →

Universal Debug Engine (UDE) is PLS's multicore-capable integrated debug, trace, and test environment (software). It supports an extremely wide range of cores, including Infineon AURIX/TriCore, NXP/ST Power Architecture (MPC56/57/58, SPC56/57/58), Arm Cortex-M/R/A, Renesas RH850, RISC-V, ARC, SuperH SH-2A, STM32, Stellar, and S32.

DEBUG · Debug probes / on-chip debugging

Overview

Target access is through the separately sold UAD family of access devices (three models: UAD2pro / UAD2next / UAD3+). Choose among the three according to use, budget, and trace requirements.

[Main new features in UDE 2024] cDSP debugging and SOTA support for AURIX TC4x, trace support for TRAVEO T2G/XMC7000 and RH850/U2B, integration of UDE SimplyTrace with RTOS Awareness (task trace), miniMCDS support (TC38x etc.), and floating-point display in trace. Supported RTOSes: SAFERTOS / FreeRTOS / PXROS-HR / MicroC/OS-II / AUTOSAR.

[Learning UDE from videos] PLS's webinar series (co-hosted with Hitex) explains UDE's main functions with live demos. Under “Learning UDE from videos” below we summarize five of them — trace-based analysis, an overview of the tools, Python automation, Arm Cortex-A/R multicore debugging, and variable visualization — so you can grasp the key points without watching.

Multicore debug and test environment. Supports advanced debugging of TriCore/AURIX and more.

Positive ONE Group supports you in Japanese, from product selection and quotes through to technical support during deployment, and proposes the optimal configuration for your target MCU, OS, quantity, and application.

Key specifications

Universal Debug Engine (UDE)
Type	Integrated debug, trace, and test environment (software)
Supported cores	AURIX/TriCore, Power, Cortex-M/R/A, RH850, RISC-V, ARC, SH-2A, and others
Features	Multicore debugging, trace, code coverage, test automation
Expansion	RTOS Awareness, MCDS/SimplyTrace, Memtool, Code Coverage
Hardware	UAD2pro / UAD2next / UAD3+ (3 models)

Technical specifications

Software functions (debug)

Universal Debug Engine (UDE)
Debug	HLL (C/C++/Rust) + assembler cross-debugging, Mixed Mode, syntax highlighting
Multicore	System-centered UI, color coding per core, synchronized run control, Multi-Program Loader
Special cores	Supports special cores such as GTM / PPU / SCRM / HSM / eTPU
Runtime observation	Real-time observation of application data with advanced visualization
FLASH	Integrated on-/off-chip flash programming (Memtool add-in)
UI	Perspectives, multi-screen, home screen, predefined target configurations

Technical specifications

Software functions (trace and analysis)

Universal Debug Engine (UDE)
Trace methods	MCDS, AURORA (AGBT/SGBT/HSSTP), Nexus, CoreSight (ETM/PTM/ITM/FTM), ARC SmaRT
Configuration	GUI configuration with UEC (Universal Emulation Configurator)
Analysis	Code Coverage (ISO 26262 structural coverage), Profiling, Execution Sequence, Call Graph
Reconstruction	Reconstructs time-aligned program flow from trace
Output formats	Raw / UTF (binary / text / HTML), VCD, TAB/SPACE, XML

Technical specifications

Software functions (automation and IDE)

Universal Debug Engine (UDE)
Object Model	COM-based API (included with all base licenses at no extra cost)
Scripting	Python / PowerShell / JavaScript / Perl / Visual Basic / C# / C++ (COM-capable languages)
Python	Embedded Python 3.12 interpreter (Script Console, auto-completion, external scripts)
Eclipse	Eclipse integration (dedicated debug perspective, all architectures, no extra cost)
Compilers	HighTec/GNU, Tasking, Keil/Arm, Wind River, Green Hills, Renesas, CodeWarrior

Technical specifications

RTOS and AUTOSAR Awareness

Universal Debug Engine (UDE)
RTOS	PXROS-HR, SAFERTOS, FreeRTOS, Sciopta, OSEK/ORTI, PXROS, CMX, uC/OS-II, rcX, Keil RTX, Nucleus PLUS
AUTOSAR	AUTOSAR Classic Platform, ARTI/ORTI support
ARTI	Trace and visualize tasks / runnables / ISRs from the ARTI file (arxml)
Display	Visualize RTOS / AUTOSAR objects and states; jump to each window

Technical specifications

AUTOSAR ARTI in detail

Universal Debug Engine (UDE)
What is ARTI?	An interface between build tools and debug/trace tools. All debug information is stored in the arxml
Support Window	Detailed display of OS objects (updated in HALT state)
Information classes	ArtiHook/OSClass/AlarmClass/ContextClass/IsrClass/MessageContainerClass/RessourceClass/StackClass/TaskClass/CoreClass
Task trace	Trace task execution, category 2 ISRs, and functions (based on ARTI hooks)
ArtiHookGenerator	CLI tool that automatically generates ARTI.c / ARTI.h (hook macros) at build time
Third-party integration	Export trace as ASAM MDF → to timing analysis tools
Vector Timing Bundle	Scheduling trace integration for MICROSAR (with TA Tool Suite)

Technical specifications

Supported MCUs (by manufacturer, combined)

Universal Debug Engine (UDE)
Infineon	AURIX TC4x/TC3xx/TC2xx, TriCore AUDO, XMC7xxx/4xxx/1xxx, TRAVEO T2G, PSoC 4, XC166/XC2000/XE166, C166/ST10, MOTIX
STMicroelectronics	Stellar SR6P/SR6G/SR5E, STM32 (all Cortex-M), SPC56x/SPC57x/SPC58x
NXP	S32G2/G3, S32V, S32Z/S32E, S32N5, S32K1/K3/K5, i.MX RT, MPC56xx/57xx, S32R, Kinetis
Renesas	RH850 (U2A/U2B/U2C, C1/D1/E1/E2/F1/P1), R-Car, RA, RZ/T2M, SuperH SH-2A
Arm (various vendors)	Cortex-R52(+), Cortex-A5x/A7x/A8/A9, Cortex-M0/3/4/7, M33/M23/M55/M52/M85, Arm7/9/11
Texas Instruments	Jacinto (TDA4/DRA8), Sitara (AM64x/AM263Px/TMS570), MSPM0 G, MSPM33
Synopsys	ARC EM/EV/HS, ARC-V
IP cores / others	Bosch GTM, DFA, Andes D23, RISC-V, SiFive, AMD/Xilinx Zynq-7000, Hilscher NETX 90, XScale
Chinese vendors	Tongxin Micro THA6, Thinktech Alioth TTA8, NOVOSENSE, GigaDevice, C*Core

Technical specifications

Learning UDE from videos (key points from 5 videos)

Universal Debug Engine (UDE)
① Trace-based debugging and runtime analysis	On-chip trace is a powerful way to analyze real-time applications without affecting runtime behavior (non-intrusively). Using the MCDS (Multi-Core Debug Solution) trace system of Infineon AURIX as an example, the video demonstrates how to get started with trace-based debugging. It explains how to identify performance bottlenecks with trace and how to find bugs caused by timing problems and parallel execution. The central theme is time-accurate reconstruction of program flow.
② Overview of the debug and trace tools	An introduction to UDE as a debug, trace, and test tool (about 40 minutes). In three parts — (1) supported microcontrollers (AURIX/TriCore, Power Architecture, Arm Cortex, RH850, and more), (2) the debugger hardware, the Universal Access Device family (UAD2pro / UAD2next / UAD3+), and (3) an overview of UDE's functions — it gives the overall picture needed to choose tools.
③ Debug automation with Python	How to use UDE's automation interface from Python (about 37 minutes). Through the UDE Object Model (a software API based on Microsoft COM), Python scripts control the target system, read target state and manipulate it (for example rewriting variables). UDE has a built-in Python 3.12 interpreter (Python Script Console) for both interactive and external script execution. It applies directly to automating routine daily work and tests.
④ Multicore debugging of Arm Cortex-A/Cortex-R SoCs	Debugging heterogeneous multicore SoCs with Arm Cortex-A53 / Cortex-R52 (about 23 minutes). Using the NXP S32 Automotive Platform (S32G, S32S) and ST Stellar as examples, it demonstrates UDE's multicore functions (synchronized core start/stop, core groups, and multicore breakpoints) and basic multicore trace.
⑤ Visualizing variables (Visualizing Variables 101)	An explanation of UDE's extensive variable-visualization functions (about 21 minutes). It demonstrates from the basics how to observe and visualize target variables in various ways — watch, memory, and graphical displays. Practical content for following running application data in real time.

Main uses

Debug and trace the target MCU in a single environment
Combine execution control, variable observation, and trace analysis
Standardize the debug environment within the team

Benefits

Hardware and analysis functions are integrated, so setup takes little effort
Analyze without switching back and forth between debugging and trace
Can be controlled from scripts and extended to automation

Environment

Supported cores: Infineon TriCore / AURIX and other multicore SoCs
Functions: debug / flash / trace (MCDS) / RTOS Awareness
Hardware: UAD (Universal Access Device)

Frequently asked questions

We cannot connect to the target via XCP. What do we need?

XCP software debugging requires supported XCP hardware: ETAS ETK (AURIX TC2x/3x/4x, Power PC SPC5x/MPC5x, Stellar SR6x, S32Zx etc.) or Vector VX (AURIX TC2x/3x/4x). When creating a new workspace, select the XCP configuration file for the target chip and set the correct IP address and TCP port. XCP needs a node-locked license (or a normal license tied to a UAD). Some uses, such as debugging security cores, may be restricted over XCP; in those cases debugging with a UAD is recommended.

We press the “Program” button every time we load a new ELF into flash. Can this be automated?

Yes. Open the Memtool dialog from Tools - Flash programming, and under General... enable “After download start Program All function automatically”. If you also enable “Automatically close Execute Command dialog when finished”, the dialog closes automatically when done.

The flash download pattern sometimes differs between ELF and HEX. Why?

Normally the download patterns of ELF and HEX are identical. If you need to patch the HEX with extra patterns not present in the ELF, UDE's Hex/ELF option takes the download pattern from the HEX and the symbol information from the ELF. The setting is under Config - Debug Server Configuration - Symbol - Hex/ELF load.

How do we debug our own bootloader that starts from flash and copies itself to RAM?

There are two main ways. (1) Prepare two build variants, one for flash and one for RAM, and develop and debug them separately (the flash variant becomes the final release). (2) Place the flash code and RAM code in separate sections (e.g. .text_flash and .text) and create a ROM copy that is copied at startup. To set breakpoints in the RAM code, enable “Set hardware breakpoint by default” under Config - Debug Server Configuration - Debug Server, because software breakpoints are lost after copying. We recommend this method, as debug information for both parts of the code is available.

How do we install UDE in an Eclipse environment and debug?

After starting Eclipse, check whether “Universal Debug Engine” appears under Debug Configurations. If not, go to Help - Install New Software, click Add to add a repository, choose UDEEclipseIntegration.zip in the UDE installation folder with Archive, select “Universal Debug Engine Eclipse Integration,” and install. Open Debug Configuration again and double-click the Universal Debug Engine item to create a launch configuration.

Why is program loading slow when the files are on a network drive?

When loading a program, the debugger creates a database file for symbol management. By default it is placed in the same directory as the program, so it is slow on a network drive. Storing the database locally with “Database directory” under Config - Debug Server Configuration - Debug Server - Symbol speeds this up.

What is the quickest way to enable or disable all breakpoints at once?

Open the project workspace with Window - Project Workspace. From the context menu of the “Breakpoints” node in the symbol explorer you can enable or disable all breakpoints at once.

Why does the Memory/SFR view show “????????”?

“????????” is shown when the memory cannot be read even though the target connection is established. Usually it is a non-existent memory region, or a region to which access is not permitted in the current processor mode.

What if we get the “Runtime components are older than required” warning, or a crash from a context menu?

The cause is an old or invalid Microsoft Visual C++ runtime version. Install Microsoft's latest runtime package (vc_redist.x86.exe up to UDE 5.2, vc_redist.x64.exe from UDE 2021). It happens when UDE setup cannot recognize a runtime installed by other software.