Transmitting a byte over UART in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this UART transmit function?

Consider the following embedded C code snippet that transmits a byte over UART. What will be the value of the UART data register (UDR) after calling uart_transmit(0x55);?

Embedded C

volatile unsigned char UDR = 0;
volatile unsigned char UCSRA = 0x20; // UDRE bit set (ready)

void uart_transmit(unsigned char data) {
    while (!(UCSRA & 0x20)) {
        // wait until UDRE bit is set
    }
    UDR = data;
}

int main() {
    uart_transmit(0x55);
    return 0;
}

A UDR will be 0xFF

B UDR will be 0x00

C UDR will be 0x55

D UDR will be 0x20

💡 Hint

Check what the function assigns to UDR after the ready bit is confirmed.

The function waits until the UDRE bit (bit 5, value 0x20) in UCSRA is set, indicating the UART data register is ready. Then it assigns the data byte 0x55 to UDR. So UDR becomes 0x55.

🧠 Conceptual

intermediate

Which statement correctly describes the UDRE bit in UART communication?

In UART communication, what does the UDRE (UART Data Register Empty) bit indicate?

A The UART data register is full and cannot accept new data

B The UART data register is empty and ready to accept new data

C The UART has received a byte successfully

D The UART transmitter is disabled

💡 Hint

Think about when you can safely write a new byte to the UART data register.

The UDRE bit is set when the UART data register is empty and ready to accept new data for transmission.

🔧 Debug

advanced

Why does this UART transmit code cause a hang?

This code is intended to transmit a byte over UART, but it causes the program to hang (infinite loop). What is the reason?

Embedded C

volatile unsigned char UCSRA = 0x00; // UDRE bit is 0 (not ready)
volatile unsigned char UDR = 0;

void uart_transmit(unsigned char data) {
    while (!(UCSRA & 0x20)) {
        // wait until UDRE bit is set
    }
    UDR = data;
}

int main() {
    uart_transmit(0xAA);
    return 0;
}

A The function does not clear the UDRE bit after transmission

B UDR register is not volatile, causing optimization issues

C Data is assigned before checking UDRE bit

D UDRE bit is never set, so the while loop never ends

💡 Hint

Look at the initial value of UCSRA and the condition in the while loop.

The UDRE bit (bit 5) in UCSRA is 0 initially and never changes, so the condition !(UCSRA & 0x20) is always true, causing an infinite loop.

📝 Syntax

advanced

Which option correctly transmits a byte over UART?

Select the code snippet that correctly waits for the UART data register to be ready and then transmits the byte data.

A

while (!(UCSRA & (1 << 5))) {}
UDR = data;

B

while (UCSRA & (1 << 5)) {}
UDR = data;

C

if (UCSRA & (1 << 5)) {
  UDR = data;
}

D

while (!(UCSRA & 0x10)) {}
UDR = data;

💡 Hint

UDRE bit is bit 5 (value 0x20). You want to wait until it is set.

The UDRE bit is bit 5 (1 << 5 = 0x20). The code waits while UDRE is 0, then writes data to UDR. Option A correctly uses this logic.

🚀 Application

expert

How many bytes are transmitted by this UART send function call?

Given the following code, how many bytes will be transmitted when uart_send_string("Hi"); is called?

Embedded C

volatile unsigned char UCSRA = 0x20; // UDRE bit set
volatile unsigned char UDR = 0;

void uart_transmit(unsigned char data) {
    while (!(UCSRA & 0x20)) {}
    UDR = data;
}

void uart_send_string(const char *str) {
    while (*str) {
        uart_transmit(*str++);
    }
}

int main() {
    uart_send_string("Hi");
    return 0;
}

A 2 bytes

B 3 bytes

C 1 byte

D 0 bytes

💡 Hint

Count the characters in the string and how the loop processes them.

The string "Hi" has 2 characters. The loop calls uart_transmit twice, once for 'H' and once for 'i'. So 2 bytes are transmitted.