Debuggers and Trace
Software debugging and tracing of executed code in order to find coding flaws and errors requires tools that are powerful, flexible and highly configurable for the task at hand. Especially when debugging an application running on a Real Time Operating System (RTOS). On top of that, CI/CD forces these tools out of their stand-alone legacy environment and into a range of software ecosystems. New perspectives about debugging software have created a new breed of tools combining all these aspects in powerful visually enhanced software aids.
Our brands

Our brands

Related articles

Whitepaper – Effective power interruption testing – how best to fail
Download the whitepaper Email E-mail address * name@company.com 8 + 2 = * First name: * Last name * Company * News, product updates and events Yes, keep me posted of the latest embedded news...
Read more
Boundary Scan Gets a Boost
Read more
Managing enterprise-wide verification results
Read more
eBook – Securing embedded & IoT systems
Read more
eBook – Data Management at the Edge
Read more
On this page you will find our Logic Solutions for JTAG-type debugging as well as software based tools for RTOS debugging. Not sure what the best solution is for your use case? Contact us!

RTOS tracing tools are essential for developers working with real-time operating systems (RTOS) due to the complexities inherent in multi-threaded and event-driven systems. Here's a breakdown of why they're needed, the benefits they offer, and the risks of not using them.
Why RTOS Tracing Tools Are Necessary
- Complexity of RTOS: RTOS environments involve multiple tasks running concurrently, sharing resources, and communicating with each other. This intricate interplay makes it difficult to understand the system's behavior using traditional debugging methods.
- Time-Critical Behavior: RTOS applications often have strict timing requirements. Understanding task execution order, context switching, and interrupt handling is crucial for ensuring real-time performance.
- Intermittent and Hard-to-Reproduce Bugs: Issues like race conditions, deadlocks, and priority inversions can be difficult to reproduce and diagnose without detailed insight into the system's runtime behavior.
Benefits of Using RTOS Tracing Tools
- Improved Understanding of System Behavior: Tracing tools provide a detailed timeline of events, showing task scheduling, interrupts, resource access, and inter-task communication. This allows developers to visualize the system's dynamics and identify performance bottlenecks or unexpected behavior.
- Faster Debugging: By providing a clear view of what's happening within the RTOS, tracing tools significantly reduce the time spent on debugging complex issues. Developers can quickly pinpoint the root cause of problems instead of relying on guesswork or time-consuming manual analysis.
- Performance Optimization: Tracing tools can help identify performance bottlenecks, such as excessive context switching, long interrupt handlers, or inefficient resource usage. This information enables developers to optimize their code for better real-time performance.
- System Verification and Validation: Tracing tools can be used to verify that the system behaves as expected under various conditions. This is particularly important in safety-critical applications where correctness and reliability are paramount.
Risks of Not Using an RTOS Tracer
- Increased Development Time: Without tracing tools, debugging RTOS applications can be extremely time-consuming and frustrating. Developers may spend countless hours trying to reproduce and diagnose issues, leading to project delays.
- Difficulty in Finding Root Causes: Intermittent and complex bugs can be very difficult to track down without detailed tracing information. This can lead to patches that mask symptoms rather than addressing the underlying problem.
- Reduced System Reliability: Undetected or unresolved issues can lead to unpredictable system behavior, crashes, or even safety hazards in critical applications.
- Challenges in Performance Tuning: Optimizing RTOS performance without tracing tools is like navigating in the dark. Developers may make changes that have unintended consequences or fail to identify the most effective optimizations.
In Summary
RTOS tracing tools are essential for developers working with real-time operating systems. They provide valuable insights into system behavior, accelerate debugging, aid in performance optimization, and improve overall system reliability. The risks of not using these tools include increased development time, difficulty in finding root causes of bugs, reduced system reliability, and challenges in performance tuning.
J-Trace PRO
J-Trace PRO is SEGGER's "all-in-one" streaming trace probe for any popular CPU core and architecture. It combines all the debug capabilities of the market-leading J-Link with the analyzing, verifying and code-profiling features of the J-Trace for Arm- and RISC-V-based architectures.
J-Trace PRO for Cortex-M
J-Trace PRO for Cortex-A/R/M-based microcontrollers supports tracing on a wide range of Arm Cortex cores.
J-Link WiFi
J-Link WiFi is a JTAG/SWD debug probe with WLAN/WiFi interface. It can communicate at high speed (up to 15MHz) with the supported target CPUs. If a wireless debug interface is required, J-Link WiFi is the perfect solution.
J-Link ULTRA plus
J-Link ULTRA+ is an ultra-fast debug probe for JTAG/SWD. It is 100% compatible with J-Link PLUS, just faster.
J-Link PRO
J-Link Pro is SEGGER's versatile JTAG/SWD programming and debug probe with USB and Ethernet interfaces.
J-Link PLUS
J-Link PLUS is a USB-powered JTAG debug probe supporting a large number of CPU cores. Based on a 32-bit RISC CPU, it can communicate at high speed with the supported target CPUs. J-Link is used around the world in tens of thousands of places for development and production (flash programming) purposes.
Percepio Tracealyzer
Percepio Tracealyzer, is a visual trace observability tool that helps developers to speed up debugging, make faster progress, and deliver great products with confidence.
Percepio DevAlert
Percepio DevAlert is a cloud-based service that provides continuous observability for embedded software. DevAlert helps developers proactively identify and address issues in their firmware remotely.
Percepio Detect
Percepio Detect is designed to enhance observability during the testing and QA phases of embedded software development.
J-Trace PRO RISC-V
J-Trace PRO for RISC-V-based microcontrollers supports tracing on a wide range of RISC-V cores.

André De Ceuninck
Software Quality | Testing | Certification
Develop and Deploy with Continuous Observability
Upscaling software issue detecting over a multitude of remote devices is possible today. Give me 30 minutes of your time and gain weeks of development time.