TRACE32 Introduction - Practical Debugging Course for MCU & RTOS Developers

Notice 🎯

To commemorate the launch of Korea's first TRACE32 course (Basic), we're issuing a 30% discount coupon (limited to the first 100 people).

Coupon link: https://inf.run/2VPew

Upgrade your career and salary

Attention aspiring MCU developers!!!

Do you want to become an MCU developer that companies are eager to hire? TRACE32 debugging skills are essential. By taking this course, you can quickly learn TRACE32 debugging methods that can be immediately applied in real-world work. You can start TRACE32 debugging practice (simulator mode) immediately upon enrollment.

TRACE32

Reasons why it should be handled well

TRACE32 is a widely used hardware debugger and program worldwide. Particularly in MCU development, TRACE32 is not only a hardware debugger but also a development environment with SDK characteristics. Especially large corporations (Samsung, Hyundai Motor, SK) and global semiconductor companies (Qualcomm, NXP, Infineon) use TRACE32 as a standard tool in MCU development stages. Therefore, for career advancement, learning how to use TRACE32 for MCU developers is not simply a choice, but an essential competency required in practical work.

This lecture explains how MCU developers can effectively use TRACE32.

The reason for creating the course

Over 14 years of solving various crash issues, I have resolved countless challenging problems (crashes, lockups, watchdog resets, hardware bugs) using TRACE32. Like a knight sleeping with his armor the night before a medieval one-on-one duel, I have even slept holding TRACE32 equipment during business trips. This is because TRACE32 equipment is like armor that protects a knight for embedded system developers.

With the hope that embedded system developers who are still working overtime would have less hardship, I conducted a TRACE32 debugging seminar targeting embedded developers and managers. However, I heard the following complaints.

• Administrator's perspective: Even when we purchase TRACE32 licenses for developers, they don't use them effectively. (Reason: Developers don't know how to properly utilize TRACE32)

• Developer's perspective: Management won't purchase TRACE32 licenses, so debugging is impossible. Additionally, there are no senior colleagues or peers who can properly teach how to debug with TRACE32.

After hearing this feedback, I thought people aren't utilizing TRACE32, which provides powerful features, as well as expected. So I decided to create an introductory TRACE32 course that MCU firmware developers who haven't used TRACE32 yet or aren't familiar with it can apply in their practical work.

Differentiation Points of the Course

This course is not simply a process of listing TRACE32 usage methods. It is a hands-on practice-centered course designed with situations that MCU developers can definitely encounter in actual work.

After taking this course...

• You can directly load the ELF files you develop with TRACE32 and debug symbols. You can check section information and information about variables and functions. Based on this, you can efficiently analyze source code you're seeing for the first time and perform debugging in the shortest time possible.

• Using TRACE32, you can set breakpoints and immediately check related global or local variables. You can also directly modify register or memory contents, allowing you to effectively handle unexpected issues.

• You can execute assembly instructions (Cortex-M3, RISC-V) for direct debugging. You can check the values of changed registers or memory contents.

• You can debug problems encountered while using the TRACE32 program. In particular, you can directly handle issues encountered during CMM script execution and immediately identify the primary cause.

You'll learn this kind of content

Detailed explanation of why MCU firmware developers should master TRACE32 from practical development and career perspectives. **Practical Development Perspective:** TRACE32 is an essential tool that significantly enhances debugging efficiency and code quality in MCU firmware development. Unlike basic debuggers, TRACE32 provides real-time trace capabilities that allow developers to analyze program execution flow, identify performance bottlenecks, and detect hard-to-find bugs that occur intermittently. Its advanced breakpoint features enable conditional debugging and complex trigger scenarios, making it invaluable for debugging interrupt-driven systems and real-time applications. The tool's memory analysis capabilities help developers optimize memory usage and detect memory leaks or corruption issues that are critical in resource-constrained MCU environments. **Career Development Perspective:** Mastering TRACE32 positions developers as highly skilled professionals in the embedded systems industry. Companies developing automotive, aerospace, medical devices, and industrial control systems specifically seek engineers proficient with advanced debugging tools like TRACE32. This expertise demonstrates deep understanding of low-level system behavior and debugging methodologies, making candidates more competitive for senior firmware engineer, embedded systems architect, and technical lead positions. The knowledge also opens opportunities in specialized fields like automotive AUTOSAR development, safety-critical systems, and high-performance embedded applications where TRACE32 proficiency is often a

Specifically explains what kind of work can be done in practical development using TRACE32.

To use TRACE32 effectively, you need to understand the basic functions of the CPU architectures supported by TRACE32. This explains the core functions of Cortex-M3/M4 processors that are widely used in MCU firmware development.

This explains the basic functions of RISC-V processors that are widely used in MCUs recently.

Let's run TRACE32 and introduce the basic commands you need to know during this process. We'll proceed with hands-on practice debugging CMM scripts.

This explains each menu of TRACE32. We will proceed with hands-on practice of setting breakpoints and debugging assembly instructions.

In a state where a RISC-V-based ELF file (u-boot) is loaded, we will conduct a hands-on exercise using the TRACE32 features covered in previous lectures. From the perspective of an MCU firmware developer, you can learn which features are used together in TRACE32 when the CPU is changed.

We will conduct specific hands-on practice for debugging symbols and loading binary files in TRACE32.

I organize frequently used commands during the debugging process while looking at the TRACE32 reference manual.

Pre-enrollment Reference Information