Printf debugging over UART in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of UART printf with buffer overflow

Consider this embedded C code snippet that sends debug messages over UART using printf. What will be the output on the UART console?

Embedded C

#include <stdio.h>
#include <string.h>

char uart_buffer[10];

int uart_send(const char *msg) {
    // Simulate UART send by copying to buffer
    strcpy(uart_buffer, msg);
    return 0;
}

int main() {
    char debug_msg[20];
    sprintf(debug_msg, "Value: %d", 12345);
    uart_send(debug_msg);
    printf("UART buffer: %s\n", uart_buffer);
    return 0;
}

A UART buffer: Value: 123456789

B UART buffer: Value: 1234

C UART buffer: Value: 12345

D Runtime error due to buffer overflow

💡 Hint

Remember that strcpy copies until the null terminator, but uart_buffer is only 10 bytes.

The uart_buffer has size 10, but the string "Value: 12345" is 12 characters long plus the null terminator (13 bytes). strcpy will overflow uart_buffer, but in this simulation it copies the full string. Since this is a simulation, the output shows the full string. In real embedded systems, this would cause overflow issues, but here the output is the full string.

🧠 Conceptual

intermediate

Why use printf debugging over UART in embedded systems?

Which of the following is the main reason developers use printf debugging over UART in embedded systems?

A To increase the speed of the embedded program execution

B To visually see variable values and program flow without a debugger

C To permanently store debug logs in non-volatile memory

D To reduce power consumption during debugging

💡 Hint

Think about what printf debugging helps you understand during development.

Printf debugging over UART allows developers to see variable values and program flow in real time on a console, which is very helpful when hardware debuggers are unavailable or limited.

🔧 Debug

advanced

Identify the cause of missing UART output

This embedded C code is supposed to send a debug message over UART using printf. However, no output appears on the UART console. What is the most likely cause?

Embedded C

#include <stdio.h>

void uart_init() {
    // UART initialization code
}

int uart_putchar(char c) {
    // Send character over UART hardware
    return 0;
}

int main() {
    uart_init();
    printf("Debug: %d\n", 42);
    return 0;
}

A The main function should return void, not int

B UART hardware is not initialized properly

C The uart_putchar function is missing a return statement

D The printf output is buffered and not flushed to UART

💡 Hint

Think about how printf sends characters and when output appears on UART.

Printf output is usually buffered. Without flushing or a newline, the output may not appear immediately on UART. Here, although there is a newline, some embedded libraries require explicit flush or implementation of _write or putchar to send characters.

📝 Syntax

advanced

Correct UART printf redirection code

Which option correctly implements the function to redirect printf output to UART by overriding the _write syscall in embedded C?

Embedded C

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

A

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

B

int _write(int file, char ptr[], int len) {
    int i = 0;
    while (ptr[i] != '\0') {
        uart_send_char(ptr[i]);
        i++;
    }
    return i;
}

C

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

D

int _write(int file, char *ptr, int len) {
    uart_send_string(ptr);
    return len;
}

💡 Hint

The _write function must return the number of bytes written and send exactly len bytes.

Option A correctly loops over len bytes and sends each character, returning len. Option A returns void which is incorrect. Option A loops until null terminator which may be less than len. Option A sends the whole string without length control, which may cause issues if ptr is not null-terminated.

🚀 Application

expert

Calculate UART debug message transmission time

An embedded system sends debug messages over UART at 115200 baud rate using printf. If a debug message is 50 characters long, approximately how long in milliseconds will it take to transmit the entire message? Assume 1 start bit, 8 data bits, no parity, and 1 stop bit per character.

A Approximately 4.35 ms

B Approximately 0.43 ms

C Approximately 8.7 ms

D Approximately 17.4 ms

💡 Hint

Calculate bits per character and total bits, then divide by baud rate.

Each character has 1 start + 8 data + 1 stop = 10 bits. For 50 characters, total bits = 500. Time = 500 bits / 115200 bits per second ≈ 0.00434 seconds = 4.35 ms.