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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this UART receive code snippet?

Consider the following embedded C code snippet that reads a byte from UART data register and stores it in a variable. What value will received_byte hold after execution?

Embedded C

volatile uint8_t UART_DR = 0x5A; // UART Data Register mock
uint8_t received_byte = 0;

// Simulate reading a byte from UART
received_byte = UART_DR;

A Undefined behavior

B 0x00

C 0xFF

D 0x5A

💡 Hint

Think about what value is stored in UART_DR and how assignment works.

The variable UART_DR is set to 0x5A. Assigning it to received_byte copies that value, so received_byte becomes 0x5A.

❓ Predict Output

intermediate

What error occurs when reading UART without checking status?

What happens if you read the UART data register without checking if data is ready?

uint8_t data = UART_DR;

A Compilation error

B You might read invalid or old data

C UART hardware resets

D Program crashes immediately

💡 Hint

Think about hardware behavior when data is not ready.

Reading UART data register without checking the status may return stale or invalid data because no new byte has arrived yet.

🔧 Debug

advanced

Why does this UART receive code cause a runtime error?

Identify the problem in this code snippet that reads a byte from UART:

uint8_t *ptr = NULL;
*ptr = UART_DR;

A Dereferencing a NULL pointer causes a runtime error

B UART_DR is not initialized

C Missing semicolon causes syntax error

D UART_DR is not volatile

💡 Hint

What happens if you write to a NULL pointer?

Dereferencing a NULL pointer leads to undefined behavior and usually a runtime crash or fault.

📝 Syntax

advanced

Which option correctly reads a byte from UART with status check?

Choose the correct code snippet that waits for UART data ready flag before reading the byte.

A while(!(UART_SR & (1 << RXNE))); uint8_t data = UART_DR;

B if(UART_SR & (1 << RXNE)) uint8_t data = UART_DR;

C uint8_t data = UART_DR; while(!(UART_SR & (1 << RXNE)));

D while(UART_SR & (1 << RXNE)); uint8_t data = UART_DR;

💡 Hint

Remember to wait until the RXNE bit is set before reading.

Option A waits in a loop until the RXNE (Receive Not Empty) bit is set, then reads the data. Others either read too early or wait incorrectly.

🚀 Application

expert

How many bytes are received after this UART interrupt handler runs?

Given this UART interrupt handler code, how many bytes will be stored in buffer after it runs once?

#define BUFFER_SIZE 4
volatile uint8_t buffer[BUFFER_SIZE];
volatile uint8_t index = 0;

void UART_IRQHandler(void) {
  if(UART_SR & (1 << RXNE)) {
    buffer[index++] = UART_DR;
    if(index >= BUFFER_SIZE) index = 0;
  }
}

A 0

B 4

C 1

D Undefined

💡 Hint

How many times does the interrupt handler run and how many bytes does it read per run?

The interrupt handler runs once per interrupt and reads one byte if RXNE is set, so it stores exactly one byte per call.

Practice

1. What does receiving a byte over UART typically involve in embedded C programming?

easy

A. Reading one character sent from another device

B. Sending multiple bytes to another device

C. Configuring the UART baud rate only

D. Resetting the microcontroller

Solution

1. Step 1: Understand UART communication basics

   UART communication involves sending and receiving data one byte at a time between devices.

2. Step 2: Identify receiving action

   Receiving a byte means reading one character sent from another device, not sending or configuring settings.

3. Final Answer:

   Reading one character sent from another device -> Option A

4. Quick Check:

   Receiving byte = Reading one character [OK]

Hint: Receiving means reading data sent from another device [OK]

Common Mistakes:

• Confusing receiving with sending data
• Thinking configuration is receiving
• Assuming multiple bytes are received at once

2. Which of the following is the correct way to check if a byte is ready to be read from UART in embedded C?

easy

A. UART_DATA = UART_STATUS & RX_READY;

B. if (UART_DATA == RX_READY) { byte = UART_STATUS; }

C. if (UART_STATUS & RX_READY) { byte = UART_DATA; }

D. while (UART_DATA != RX_READY) { }

Solution

1. Step 1: Understand UART status checking

   To check if data is ready, we test a status register bit (e.g., RX_READY) using bitwise AND.

2. Step 2: Correct syntax for reading byte

   If data is ready, read the byte from the data register. if (UART_STATUS & RX_READY) { byte = UART_DATA; } correctly does this.

3. Final Answer:

   if (UART_STATUS & RX_READY) { byte = UART_DATA; } -> Option C

4. Quick Check:

   Status & RX_READY then read data [OK]

Hint: Check status with bitwise AND before reading data [OK]

Common Mistakes:

• Comparing data register to status bits
• Assigning instead of checking bits
• Using wrong registers for status or data

3. What will be the output of this code snippet if UART_DATA contains 0x41 ('A') and UART_STATUS has RX_READY set?

char received_byte;
if (UART_STATUS & RX_READY) {
    received_byte = UART_DATA;
}
printf("%c", received_byte);

medium

A. Error

B. A

C. 0

D. No output

Solution

1. Step 1: Check condition for data ready

   UART_STATUS & RX_READY is true, so the if block executes.

2. Step 2: Assign and print received byte

   received_byte is assigned UART_DATA value 0x41, which is ASCII 'A'. printf prints 'A'.

3. Final Answer:

   A -> Option B

4. Quick Check:

   UART_DATA 0x41 = 'A' printed [OK]

Hint: If RX_READY set, read UART_DATA and print it [OK]

Common Mistakes:

• Assuming no output if condition true
• Confusing hex 0x41 with zero
• Expecting error without syntax issues

4. Identify the error in this UART receive code snippet:

char byte;
if (UART_STATUS & RX_READY);
{
    byte = UART_DATA;
}

medium

A. Semicolon after if condition causes unconditional block execution

B. UART_DATA should be UART_STATUS

C. Missing initialization of byte variable

D. RX_READY should be checked with equality operator

Solution

1. Step 1: Analyze if statement syntax

   The semicolon after if condition ends the if statement prematurely.

2. Step 2: Effect of semicolon on code block

   The block following runs always, ignoring the if condition, causing logic error.

3. Final Answer:

   Semicolon after if condition causes unconditional block execution -> Option A

4. Quick Check:

   Semicolon after if = unconditional block [OK]

Hint: No semicolon immediately after if(condition) [OK]

Common Mistakes:

• Ignoring semicolon after if
• Confusing data and status registers
• Thinking variable must be initialized before if

5. You want to receive a byte over UART without blocking your program if no data is available. Which approach is best in embedded C?

hard

A. Reset UART peripheral before every read

B. Use a blocking read function that waits until data arrives

C. Read UART_DATA directly without checking status

D. Check UART status register for RX_READY before reading data

Solution

1. Step 1: Understand non-blocking UART receive

   Non-blocking means program continues if no data; so check status first.

2. Step 2: Choose correct method

   Checking RX_READY bit before reading ensures data is available and avoids waiting.

3. Final Answer:

   Check UART status register for RX_READY before reading data -> Option D

4. Quick Check:

   Check status before read to avoid blocking [OK]

Hint: Always check RX_READY before reading UART_DATA [OK]

Common Mistakes:

• Using blocking read causing program to wait
• Reading data without checking status
• Resetting UART unnecessarily