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.