Printf debugging over UART in Embedded C - Step-by-Step Execution

Concept Flow - Printf debugging over UART

Start Program

↓

Initialize UART

↓

Run Code

↓

Call printf()

↓

Format String

↓

Send Data via UART

↓

Receive Data on PC

↓

View Debug Output

↓

Continue Program Execution

The program starts, sets up UART, then uses printf to send formatted debug info over UART to a PC for viewing.

Execution Sample

Embedded C

#include <stdio.h>
void uart_init() { /* setup UART registers */ }
int main() {
  uart_init();
  printf("Value: %d\n", 42);
  while(1); // loop
}

This code initializes UART and prints a number over UART using printf for debugging.

Execution Table

Step	Action	Evaluation	Result
1	Start main()	None	Program begins
2	Call uart_init()	Setup UART registers	UART ready for communication
3	Call printf("Value: %d\n", 42)	Format string with 42	String "Value: 42\n" prepared
4	Send each character over UART	Send 'V', 'a', 'l', 'u', 'e', ':', ' ', '4', '2', '\n'	Characters transmitted serially
5	Receive characters on PC terminal	Display characters	Output shows: Value: 42
6	Enter infinite loop	None	Program waits
7	End	No further action	Program running, debug output sent

💡 Program runs indefinitely after sending debug output

Variable Tracker

Variable	Start	After uart_init()	After printf() call	Final
UART registers	Uninitialized	Configured	Configured	Configured
Formatted string buffer	Empty	Empty	"Value: 42\n"	"Value: 42\n"

Key Moments - 3 Insights

Why does printf send data over UART instead of the screen?

Because in embedded systems, printf is often redirected to UART hardware, so output goes through UART pins, not a monitor. See execution_table step 4.

What happens if UART is not initialized before printf?

Data sent by printf may not transmit correctly or at all, so no debug output appears. Refer to execution_table step 2 where uart_init() prepares UART.

Why is there an infinite loop after printf?

To keep the program running so the debug output can be read. Without it, the program might reset or stop. See execution_table step 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the formatted string prepared by printf at step 3?

A "42"

B "Value: %d\n"

C "Value: 42\n"

D "\nValue: 42"

💡 Hint

Check the 'Result' column in execution_table row for step 3

At which step does the UART hardware get configured?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for UART setup

If uart_init() was skipped, what would likely happen to the debug output?

A Output might not appear or be garbled

B Output would still appear correctly

C Program would crash immediately

D Output would appear on a screen instead

💡 Hint

Refer to key_moments about UART initialization importance

Concept Snapshot

Printf debugging over UART:
- Initialize UART hardware first
- printf sends formatted strings via UART
- Characters transmit serially to PC
- PC terminal shows debug output
- Use infinite loop to keep program running
- Helps see variable values live

Full Transcript

This example shows how embedded C programs use printf debugging over UART. The program starts and initializes UART hardware to prepare for serial communication. Then, printf formats a string with a number and sends it character by character over UART. A PC connected to UART receives and displays the debug message. The program then enters an infinite loop to keep running so the output can be read. This method helps developers see live debug info from microcontrollers without screens.

Practice

1. What is the main purpose of using printf debugging over UART in embedded C?

easy

A. To store data permanently in memory

B. To increase the speed of the embedded device

C. To send debug messages from the embedded device to a computer or terminal

D. To control hardware pins directly

Solution

1. Step 1: Understand UART communication

   UART allows serial communication between the embedded device and external devices like a PC.

2. Step 2: Role of printf debugging

   Using printf over UART sends text messages to the PC for debugging and monitoring program behavior.

3. Final Answer:

   To send debug messages from the embedded device to a computer or terminal -> Option C

4. Quick Check:

   UART + printf = debug messages [OK]

Hint: Printf over UART sends messages to PC for debugging [OK]

Common Mistakes:

• Thinking printf speeds up the device
• Confusing UART with memory storage
• Assuming printf controls hardware pins

2. Which of the following is the correct way to redirect printf output to UART in embedded C?

easy

A. Call printf directly without UART initialization

B. Set a GPIO pin high to enable printf

C. Use scanf to read UART data

D. Implement a custom _write function that sends characters via UART

Solution

1. Step 1: Understand printf redirection

   Standard printf sends output to stdout, which must be redirected to UART by implementing a low-level write function.

2. Step 2: Custom _write function role

   Implementing _write sends each character to UART transmit, enabling printf output over UART.

3. Final Answer:

   Implement a custom _write function that sends characters via UART -> Option D

4. Quick Check:

   Redirect printf by custom _write [OK]

Hint: Redirect printf by writing _write function sending UART chars [OK]

Common Mistakes:

• Calling printf without UART setup
• Using scanf instead of printf for output
• Trying to enable printf by GPIO pin

3. Given the code below, what will be the output sent over UART?

void UART_SendChar(char c);

int _write(int file, char *ptr, int len) {
  for (int i = 0; i < len; i++) {
    UART_SendChar(ptr[i]);
  }
  return len;
}

int main() {
  printf("Temp: %d C\n", 25);
  return 0;
}

medium

A. Temp: 25 C\n

B. Temp: %d C\n

C. Temp: 25 C

D. No output because UART_SendChar is not defined

Solution

1. Step 1: Understand _write function

   The _write function sends each character of the printf string to UART_SendChar, which transmits it over UART.

2. Step 2: Analyze printf output

   printf formats the string "Temp: 25 C\n" and _write sends it character by character.

3. Final Answer:

   Temp: 25 C\n -> Option A

4. Quick Check:

   Formatted printf string sent via UART [OK]

Hint: Printf formats string, _write sends chars via UART [OK]

Common Mistakes:

• Thinking %d prints literally
• Ignoring newline character
• Assuming UART_SendChar undefined means no output

4. What is the main problem in this code snippet for printf debugging over UART?

void UART_SendChar(char c) {
  while (!(UART->SR & UART_SR_TXE));
  UART->DR = c;
}

int _write(int file, char *ptr, int len) {
  for (int i = 0; i < len; i++) {
    UART_SendChar(ptr[i]);
  }
  return len;
}

int main() {
  printf("Hello UART\n");
  return 0;
}

medium

A. UART peripheral is not initialized before use

B. UART_SendChar does not wait for TXE flag

C. _write function returns wrong length

D. printf is not called in main

Solution

1. Step 1: Check UART_SendChar function

   UART_SendChar waits for TXE flag and writes data, so it is correct.

2. Step 2: Check UART initialization

   The code does not show UART initialization, which is required before sending data.

3. Final Answer:

   UART peripheral is not initialized before use -> Option A

4. Quick Check:

   Missing UART init causes no transmission [OK]

Hint: Always initialize UART before sending data [OK]

Common Mistakes:

• Ignoring UART initialization step
• Thinking TXE flag wait is missing
• Believing _write return value is incorrect

5. You want to debug a sensor reading using printf over UART. The sensor value is an integer that can be zero or negative. Which printf format specifier and UART setup is best to correctly display the value including negatives?

hard

A. Use %f in printf without UART redirection

B. Use %d in printf and ensure UART is initialized and _write redirects output

C. Use %x in printf and send data directly to GPIO pins

D. Use %u in printf and skip UART initialization

Solution

1. Step 1: Choose correct format specifier

   %d prints signed integers including zero and negatives correctly, unlike %u (unsigned) or %x (hex).

2. Step 2: Ensure UART setup

   UART must be initialized and printf output redirected via _write to UART for messages to appear on terminal.

3. Final Answer:

   Use %d in printf and ensure UART is initialized and _write redirects output -> Option B

4. Quick Check:

   Signed int format + UART init + _write = correct debug [OK]

Hint: Use %d and proper UART init with _write for signed values [OK]

Common Mistakes:

• Using %u which can't show negatives
• Skipping UART initialization
• Sending data to GPIO instead of UART