Receiving a byte over UART in Embedded C - Step-by-Step Execution

Concept Flow - Receiving a byte over UART

Start UART Receive

↓

Wait for Data Ready Flag

↓

Read Byte from UART Data Register

↓

Store Byte in Variable

↓

Process or Use Byte

↓

End Receive

This flow shows how a program waits for a byte to arrive via UART, reads it, stores it, and then uses it.

Execution Sample

Embedded C

while (!(UART_SR & (1 << RXNE_FLAG))) {}
uint8_t received_byte = UART_DR;
// Use received_byte

Waits until UART data is ready, then reads one byte from the UART data register.

Execution Table

Step	UART_SR (Status Register)	Condition (RXNE_FLAG set?)	Action	Variable received_byte
1	0x00	False	Wait (loop continues)	undefined
2	0x00	False	Wait (loop continues)	undefined
3	0x20	True	Exit loop, read UART_DR=0x41	0x41
4	0x20	True	Use received_byte=0x41	0x41

💡 RXNE_FLAG set in UART_SR, indicating data ready; loop exits and byte is read.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
UART_SR	0x00	0x00	0x00	0x20	0x20
received_byte	undefined	undefined	undefined	0x41	0x41

Key Moments - 3 Insights

Why does the program keep looping before reading the byte?

Because the RXNE_FLAG in UART_SR is not set yet (see steps 1 and 2 in execution_table), so the program waits until data arrives.

What happens when RXNE_FLAG becomes true?

The loop condition becomes false, so the program exits the loop and reads the byte from UART_DR (step 3).

Why do we read UART_DR only after RXNE_FLAG is set?

Because RXNE_FLAG signals that new data is ready to read; reading UART_DR before that could give invalid data (see exit_note).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of received_byte at Step 2?

A 0x41

B 0x00

C undefined

D 0x20

💡 Hint

Check the 'Variable received_byte' column at Step 2 in execution_table.

At which step does the condition RXNE_FLAG become true, allowing the loop to exit?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Condition (RXNE_FLAG set?)' column in execution_table.

If UART_SR never sets RXNE_FLAG, what happens to the loop?

A It exits immediately

B It loops forever waiting

C It reads garbage data

D It skips reading UART_DR

💡 Hint

Refer to the loop condition and steps 1-2 in execution_table where RXNE_FLAG is false.

Concept Snapshot

Receiving a byte over UART:
- Wait until RXNE_FLAG in UART_SR is set
- Read byte from UART_DR
- Store byte in a variable
- Use the byte as needed
Always check RXNE_FLAG before reading to avoid invalid data.

Full Transcript

This example shows how to receive a byte over UART in embedded C. The program waits in a loop until the RXNE_FLAG bit in the UART status register (UART_SR) is set, indicating that a new byte has arrived. Once the flag is set, the program reads the byte from the UART data register (UART_DR) and stores it in a variable called received_byte. The program then can use this byte for further processing. The execution table traces each step, showing the status register, the condition check, the action taken, and the value of received_byte. Key moments clarify why the loop waits and when it exits. The visual quiz tests understanding of variable values and loop behavior. The snapshot summarizes the key steps to safely receive a byte over UART.

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