Practical Tips for Hardware Debugging with Keil5

# Keil5 Hardware Debugging Tips and Tricks

## 2.1 Breakpoint Debugging

### 2.1.1 Setting and Using Breakpoints

Setting breakpoints in Keil5 is straightforward; simply click on the left side of the line number in the code. Breakpoints are indicated by a red circle.

To delete a breakpoint, just click on it again.

Breakpoints can be used to pause program execution at specific points, allowing you to check the program's state. This is very useful for debugging code, as it lets you examine variable values, check the contents of registers, and step through the code line by line.

### 2.1.2 Breakpoint Conditions and Filtering

In addition to setting simple breakpoints, Keil5 also allows you to set conditional breakpoints. Conditional breakpoints will trigger only when a specific condition is met.

For instance, you can set a breakpoint to trigger only when the value of a specific variable is greater than 10. This is particularly useful for debugging errors that occur only under certain conditions.

Keil5 also allows you to filter breakpoints. This allows you to trigger only specific types of breakpoints.

For example, you can filter out breakpoints that trigger only in source code files. This is very useful when debugging large projects where you might not want to trigger breakpoints in library code.

## 2. Keil5 Debugging Techniques

### 2.1 Breakpoint Debugging

#### 2.1.1 Setting and Using Breakpoints

Breakpoints are one of the most commonly used tools in debugging, allowing the program execution to pause at a specified location for state inspection. In Keil5, breakpoints can be set with the following steps:

1. Place the cursor at the desired breakpoint location in the source code editor.
2. Right-click and select "Toggle Breakpoint" or press F9.
3. Breakpoints will appear as red circles next to the line numbers.

Once set, the program will pause at that location when executed, and the debug window will appear. The debug window includes:

***Program Counter (PC):** The address of the instruction currently being executed.
***Registers:** The current values of the CPU registers.
***Stack:** The stack frames for function calls and local variables.
***Variables:** The values of variables in the current scope.

#### 2.1.2 Breakpoint Conditions and Filtering

Besides regular breakpoints, Keil5 also allows setting conditional and filtered breakpoints.

**Conditional breakpoints:** Trigger a breakpoint only when a specific condition is met. For example, set a conditional breakpoint to trigger only when variable `x` is greater than 10.

**Filtered breakpoints:** Trigger only breakpoints that meet specific conditions. For example, set a filtered breakpoint to trigger only for breakpoints associated with a specific function.

### 2.2 Step-by-Step Debugging

#### 2.2.1 Modes and Usage of Step-by-Step Debugging

Step-by-step debugging allows for the execution of programs one step at a time, checking the program state after each step. In Keil5, there are several step-by-step debugging modes:

***F10:** Execute the next instruction step by step.
***F11:** Execute the next line of source code step by step.
***Shift+F11:** Step into a function call.

#### 2.2.2 Viewing Registers and Memory

During step-by-step debugging, you can examine the contents of registers and memory. The register window displays the current values of the CPU registers, while the memory window shows the contents of memory within a specified address range.

### 2.3 Variable Monitoring

#### 2.3.1 Viewing and Modifying Variables

Keil5 allows you to view and modify variable values. The variables window displays the values of all variables in the current scope. You can right-click on a variable and choose "Modify Value" to change its value.

#### 2.3.2 Monitoring Variables and Breakpoints

Keil5 also allows monitoring variable values. You can right-click on a variable and choose "Add Watch" to add it to the watch list. When the value of a variable changes, the watch list will be updated.

Additionally, you can set watchpoint breakpoints that trigger only when the watched variable's value changes. This is very useful for debugging errors related to specific variables.

## 3. Keil5 Debugging Practices

### 3.1 Hardware Debugging Interfaces

#### 3.1.1 JTAG Interface and SWD Interface

Keil5 supports two common hardware debugging interfaces: JTAG (Joint Test Action Group) and SWD (Serial Wire Debug).

- **JTAG Interface:** A parallel debugging interface that communicates using four signal lines (TCK, TMS, TDI, TDO). The JTAG interface is typically used for larger chips and offers more comprehensive debugging capabilities.
- **SWD Interface:** A serial debugging interface that communicates using only two signal lines (SWDIO, SWCLK). The SWD interface is generally used for smaller chips and offers the advantages of low cost and low power consumption.

#### ***

***mon debuggers include:

- **Emulator:** Provides the most comprehensive debugging capabilities, allowing real-time code execution and inspection of registers and memory.
- **Simulator:** Offers similar functionality to an emulator but at a lower cost.
- **JTAG/SWD Adapter:** Supports basic debugging features, such as setting breakpoints and step-by-step debugging.

The connection of the debugger to the target board depends on the debugging interface.

- **JTAG Interface:** Connect the debugger to the target board's JTAG interface using a JTAG connection cable.
- **SWD Interface:** Connect the debugger to the target board's SWD interface using an SWD connection cable.

### 3.2 Common Hardware Issues Troubleshooting