Printf debugging over UART in Embedded C - Mini Project: Build & Apply

Printf debugging over UART

📖 Scenario: You are working on a small embedded device that communicates with a computer using UART (serial communication). You want to see messages from your device on the computer screen to help find and fix problems in your code. This is called printf debugging.UART sends text messages one character at a time. To use printf debugging, you need to set up UART and then send messages using printf.

🎯 Goal: Set up UART communication and use printf to send debugging messages over UART. You will create a simple program that initializes UART, sends a message, and prints a variable value to help you understand what your device is doing.

📋 What You'll Learn

Create a UART initialization function called UART_Init.

Create a function called UART_SendChar to send one character over UART.

Redirect printf output to use UART_SendChar.

Send a debugging message using printf that shows a variable value.

💡 Why This Matters

🌍 Real World

Printf debugging over UART is a common way to see what an embedded device is doing without needing complex debugging tools. It helps developers find bugs and understand program flow.

💼 Career

Embedded software engineers often use UART debugging to test and troubleshoot firmware on microcontrollers in devices like sensors, IoT gadgets, and consumer electronics.

1

Set up UART initialization

Write a function called UART_Init that sets up UART registers for 9600 baud rate. For this example, just create an empty function void UART_Init(void) {} as a placeholder.

Embedded C

# Write the UART_Init function below
// Your code here

Hint

Start by writing the function header and empty body for UART_Init.

2

Create UART_SendChar function

Write a function called UART_SendChar that takes a char parameter named c and sends it over UART. For this example, just create an empty function void UART_SendChar(char c) {} as a placeholder.

Embedded C

void UART_Init(void) {
    // UART initialization code here (empty for now)
}

// Write the UART_SendChar function below
// Your code here

Hint

Write the function header and empty body for UART_SendChar.

3

Redirect printf to UART_SendChar

Write a function called int fputc(int ch, FILE *f) that calls UART_SendChar with ch cast to char and returns ch. This will redirect printf output to UART.

Embedded C

void UART_Init(void) {
    // UART initialization code here (empty for now)
}

void UART_SendChar(char c) {
    // UART send character code here (empty for now)
}

// Redirect printf output to UART_SendChar
// Your code here

Hint

Implement fputc to send each character using UART_SendChar.

4

Send debugging message with printf

In the main function, call UART_Init() first. Then create an integer variable value with value 42. Use printf to send the message "Debug: value = %d\n" with value.

Embedded C

void UART_Init(void) {
    // UART initialization code here (empty for now)
}

void UART_SendChar(char c) {
    // UART send character code here (empty for now)
}

int fputc(int ch, FILE *f) {
    UART_SendChar((char)ch);
    return ch;
}

int main(void) {
    // Your code here
}

Hint

Initialize UART, create value, and print the debug message using printf.

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