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

Concept Flow - Transmitting a byte over UART

Start Transmission

↓

Check UART TX Ready?

No→Wait

Yes↓

Load Byte into TX Register

↓

UART Sends Byte

↓

Transmission Complete

↓

End

The program waits until UART is ready, loads the byte to send, then UART transmits it and finishes.

Execution Sample

Embedded C

while(!UART_TX_READY());
UART_TX_REG = data_byte;
// UART hardware sends the byte automatically

Waits for UART ready, then writes the byte to the transmit register to send it.

Execution Table

Step	UART_TX_READY()	Condition	Action	UART_TX_REG	Output
1	false	No	Wait	unchanged	none
2	false	No	Wait	unchanged	none
3	true	Yes	Load byte	0x4A	start sending 0x4A
4	N/A	N/A	Byte sent by UART hardware	0x4A	byte transmitted
5	N/A	N/A	Transmission complete	0x4A	done

💡 UART_TX_READY() becomes true, byte loaded and sent, transmission completes

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
UART_TX_READY()	false	false	false	true	N/A	N/A
UART_TX_REG	0x00	0x00	0x00	0x4A	0x4A	0x4A
Output	none	none	none	start sending 0x4A	byte transmitted	done

Key Moments - 3 Insights

Why do we wait for UART_TX_READY() before loading the byte?

Because UART_TX_READY() tells us if the UART hardware is ready to accept a new byte. Loading before ready would overwrite data. See steps 1-3 in execution_table.

Does writing to UART_TX_REG immediately send the byte?

No, writing loads the byte into the UART hardware buffer. The hardware then sends it automatically, as shown in steps 3-4.

What happens if we skip the wait loop?

If we skip waiting, we might overwrite UART_TX_REG before the previous byte is sent, causing data loss. The wait ensures safe transmission (see steps 1-3).

Visual Quiz - 3 Questions

Look at the execution_table, what is UART_TX_READY() at step 3?

A N/A

B false

C true

D unknown

💡 Hint

Check the 'UART_TX_READY()' column at step 3 in execution_table.

At which step does the byte get loaded into UART_TX_REG?

A Step 1

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'UART_TX_REG' columns in execution_table.

If UART_TX_READY() never becomes true, what happens?

A The program waits forever in the loop

B The byte is sent immediately

C UART_TX_REG is overwritten repeatedly

D Transmission completes without sending

💡 Hint

Refer to the wait loop in the code and steps 1-2 in execution_table.

Concept Snapshot

Transmitting a byte over UART:
1. Wait until UART_TX_READY() returns true.
2. Write the byte to UART_TX_REG.
3. UART hardware sends the byte automatically.
4. Do not write before ready to avoid data loss.
5. This ensures safe, sequential byte transmission.

Full Transcript

This visual execution shows how to send a byte over UART in embedded C. First, the program waits until the UART hardware signals it is ready to send a new byte by checking UART_TX_READY(). This prevents overwriting data. Once ready, the byte is loaded into the UART transmit register UART_TX_REG. The UART hardware then sends the byte automatically. The execution table traces each step, showing the wait, the loading of the byte, and the transmission completion. Key moments clarify why waiting is necessary and how the hardware handles sending. The quiz tests understanding of the readiness check, loading step, and consequences of skipping the wait. The snapshot summarizes the safe sequence to transmit a byte over UART.

Practice

1. What is the main purpose of waiting for the UART transmit buffer to be empty before sending a byte?

easy

A. To change the baud rate

B. To reset the UART hardware

C. To clear the receive buffer

D. To ensure the previous byte has been sent and avoid data loss

Solution

1. Step 1: Understand UART transmit buffer role

   The UART transmit buffer holds the byte to be sent. It must be empty before loading a new byte.

2. Step 2: Reason why waiting is necessary

   If you send a byte before the buffer is empty, the previous byte might be overwritten, causing data loss.

3. Final Answer:

   To ensure the previous byte has been sent and avoid data loss -> Option D

4. Quick Check:

   Wait for buffer empty = prevent data loss [OK]

Hint: Always wait for transmit buffer empty before sending [OK]

Common Mistakes:

• Ignoring the transmit buffer status
• Confusing transmit and receive buffers
• Trying to send bytes too fast

2. Which of the following code snippets correctly waits for the UART transmit buffer to be ready before sending a byte data using a register UART_STATUS with bit 5 as TX_READY flag?

easy

A. while (!(UART_STATUS & (1 << 5))); UART_DATA = data;

B. if (UART_STATUS & (1 << 5)) UART_DATA = data;

C. UART_DATA = data; while (!(UART_STATUS & (1 << 5)));

D. while (UART_STATUS & (1 << 5)) UART_DATA = data;

Solution

1. Step 1: Understand the TX_READY flag meaning

   Bit 5 set means transmit buffer is ready (empty), so wait until it is set.

2. Step 2: Analyze each code snippet

   while (!(UART_STATUS & (1 << 5))); UART_DATA = data; waits in a loop until bit 5 is set, then sends data. This is correct. if (UART_STATUS & (1 << 5)) UART_DATA = data; sends data only if ready once, no wait. UART_DATA = data; while (!(UART_STATUS & (1 << 5))); sends data before waiting, risking overwrite. while (UART_STATUS & (1 << 5)) UART_DATA = data; loops while bit 5 is set, which is opposite logic.

3. Final Answer:

   while (!(UART_STATUS & (1 << 5))); UART_DATA = data; -> Option A

4. Quick Check:

   Wait until TX_READY set, then send [OK]

Hint: Use while loop to wait for TX_READY bit set [OK]

Common Mistakes:

• Using if instead of while to wait
• Sending data before waiting
• Checking wrong bit or wrong condition

3. Given the following code snippet, what will be the output if UART_STATUS initially has bit 5 cleared and then set after some time?

while (!(UART_STATUS & (1 << 5))) {
  // wait
}
UART_DATA = 0xAB;

medium

A. The byte 0xAB is sent immediately without waiting

B. The byte 0xAB is sent after waiting for TX_READY

C. The code causes an infinite loop

D. The UART_DATA register is never written

Solution

1. Step 1: Analyze the while loop condition

   The loop waits while bit 5 of UART_STATUS is 0 (not ready). Initially bit 5 is cleared, so it waits.

2. Step 2: Consider bit 5 changing to set

   When bit 5 becomes set, the condition becomes false, loop exits, and UART_DATA is assigned 0xAB.

3. Final Answer:

   The byte 0xAB is sent after waiting for TX_READY -> Option B

4. Quick Check:

   Wait loop exits when ready, then send byte [OK]

Hint: Wait loop exits only when TX_READY bit is set [OK]

Common Mistakes:

• Assuming immediate send without waiting
• Thinking loop never ends
• Confusing bit set/clear logic

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

UART_DATA = data;
while (!(UART_STATUS & (1 << 5))) {
  // wait
}

medium

A. UART_DATA register is not assigned any value

B. The while loop condition is incorrect, should check bit 4 instead

C. The data is sent before checking if UART is ready, risking overwrite

D. The code correctly waits before sending data

Solution

1. Step 1: Check order of operations

   The code writes data to UART_DATA before waiting for TX_READY flag.

2. Step 2: Understand risk of overwriting

   If UART is not ready, writing data first can overwrite previous byte, causing data loss.

3. Final Answer:

   The data is sent before checking if UART is ready, risking overwrite -> Option C

4. Quick Check:

   Send only after waiting for TX_READY [OK]

Hint: Always wait before writing UART_DATA [OK]

Common Mistakes:

• Writing data before waiting
• Checking wrong status bit
• Missing wait loop entirely

5. You want to send an array of bytes data[5] = {0x10, 0x20, 0x30, 0x40, 0x50} over UART. Which code snippet correctly transmits all bytes ensuring no data loss?

hard

A. for (int i = 0; i < 5; i++) { while (!(UART_STATUS & (1 << 5))); UART_DATA = data[i]; }

B. for (int i = 0; i < 5; i++) { UART_DATA = data[i]; while (!(UART_STATUS & (1 << 5))); }

C. int i = 0; while (i < 5) { UART_DATA = data[i]; i++; }

D. for (int i = 0; i < 5; i++) { UART_DATA = data[i]; }

Solution

1. Step 1: Understand the need to wait before sending each byte

   Each byte must be sent only after UART transmit buffer is ready to avoid overwriting.

2. Step 2: Analyze each option

   for (int i = 0; i < 5; i++) { while (!(UART_STATUS & (1 << 5))); UART_DATA = data[i]; } waits before sending each byte, ensuring safe transmission. for (int i = 0; i < 5; i++) { UART_DATA = data[i]; while (!(UART_STATUS & (1 << 5))); } sends byte first then waits, risking overwrite. int i = 0; while (i < 5) { UART_DATA = data[i]; i++; } sends bytes without waiting. for (int i = 0; i < 5; i++) { UART_DATA = data[i]; } sends all bytes without any wait, causing data loss.

3. Final Answer:

   for (int i = 0; i < 5; i++) { while (!(UART_STATUS & (1 << 5))); UART_DATA = data[i]; } -> Option A

4. Quick Check:

   Wait before each send to avoid data loss [OK]

Hint: Wait before sending each byte in loop [OK]

Common Mistakes:

• Sending bytes without waiting
• Waiting after sending bytes
• Ignoring transmit buffer status