Scribd
Upload
7 views

Debugging_Controller_stucking

Uploaded by

shoaib.nrtc
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
7 views

Debugging_Controller_stucking

Uploaded by

shoaib.nrtc
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Full Debugging Conversation:

1. **Problem Identification**:

- You initially reported that your STM32 controller was stuck inside a routine, and the UART

debugging interrupts were not triggering.

- Debugging in Keil resulted in different execution behavior, making it harder to trace the problem

directly.

2. **Debugging Steps Taken**:

- **PC Register**: Program Counter (`0x080002C8`) was inspected and traced to corresponding

instructions in the disassembly view.

- **Call Stack**: Registers and the memory pointed to by the Stack Pointer (SP) and Link Register

(LR) were analyzed.

- **Disassembly Analysis**:

- Instructions at `0x080002C8`, `0x080002CA`, and other key addresses were inspected to

identify where the code was branching.

- Function pointers and their initialization were validated.

- **Fault Registers**: Fault-related registers like HFSR, CFSR, MMFAR, and BFAR were manually

inspected in the memory viewer.

3. **Key Insights from Fault Registers**:

- HFSR (`0xE000ED2C`) indicated a forced Hard Fault due to fault escalation.

- CFSR (`0xE000ED28`) pointed to a stacking error (`STKERR`), likely caused by invalid stack

pointer usage.

- BFAR (`0xE000ED38`) contained an invalid address (`0xF8ED00E0`), pointing to potential

pointer corruption.
4. **Memory Inspections**:

- **Function Pointers**:

- `r0` was traced to `0x080002F4`, and the address (`0x080001AD`) was inspected.

- `0x080001AD` was found to be unaligned, which would result in an invalid branch.

- **Invalid Branch**:

- Memory at `0x080001AC` contained a valid `BL.W` instruction, but subsequent code execution

was analyzed for stack overflow.

- **Invalid Memory Access**:

- At `0xF8ED00E0`, data was observed instead of valid code, confirming a corrupted memory

pointer.

5. **Root Cause Hypotheses**:

- **Stack Overflow**: Insufficient stack size or recursive calls leading to corruption.

- **Pointer Corruption**: An uninitialized or mismanaged function pointer causing an invalid

branch.

- **Invalid Memory Access**: Misaligned or invalid memory being accessed during function calls or

interrupt handling.

6. **Fix Recommendations**:

- **Increase Stack Size**:

- Update the linker script to allocate a larger stack.

- Use known patterns to detect stack overflows during runtime.

- **Validate Function Pointers**:

- Ensure all function pointers are initialized before use.

- Force alignment by setting bit 0 for Thumb mode.

- **Enable Debug Fault Handlers**:


- Enable SCB handlers for memory, bus, and usage faults:

```c

SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk | SCB_SHCSR_BUSFAULTENA_Msk |

SCB_SHCSR_USGFAULTENA_Msk;

```

- **Implement Custom Fault Handlers**:

- Add a custom Hard Fault handler to capture faulting addresses and stack states:

```c

void HardFault_Handler(void) {

uint32_t *stack = (uint32_t *)__get_MSP();

uint32_t pc = stack[6]; // Program Counter

uint32_t lr = stack[5]; // Link Register

while (1); // Halt for debugging

```

7. **Testing Recommendations**:

- Step through the code to trace invalid branches.

- Use hardware breakpoints and stack monitoring to catch stack overflows early.

- Validate all pointer arithmetic and ensure memory addresses are within valid ranges.

8. **Final Notes**:

- This conversation covered detailed debugging of your STM32 microcontroller, including

analyzing disassembly, memory, and fault registers.

- The steps provided aim to systematically identify and resolve the issue, ensuring a robust and

fault-free program.
This detailed document includes all interactions and insights shared during the debugging process.

You might also like