Transmitting a byte over UART in Embedded C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is UART in embedded systems?

UART stands for Universal Asynchronous Receiver/Transmitter. It is a hardware communication protocol used to send and receive data one byte at a time asynchronously.

beginner

Which register is commonly checked before sending a byte over UART?

The Transmit Data Register Empty (TXE) flag or equivalent is checked to ensure the UART is ready to send a new byte.

intermediate

Why do we wait for the TXE flag before writing data to the UART data register?

Waiting for the TXE flag ensures the previous byte has been moved from the data register to the shift register, so the data register is free to accept a new byte without overwriting.

beginner

Show a simple C code snippet to transmit a byte over UART assuming a register UART_DR and a flag UART_SR_TXE.

while (!(UART_SR & UART_SR_TXE)) { } // Wait until TXE is set UART_DR = byte_to_send; // Write byte to data register

beginner

What does asynchronous mean in UART communication?

Asynchronous means data is sent without a shared clock signal. Instead, start and stop bits frame each byte so the receiver knows when data begins and ends.

What must you check before writing a byte to the UART data register?

A If the UART is powered off

B If the receive buffer is full

C If the transmit buffer is empty (TXE flag)

D If the baud rate is set

You check the TXE flag to ensure the transmit buffer is empty and ready to accept a new byte.

What does UART stand for?

A Universal Asynchronous Receiver/Transmitter

B Universal Automatic Register Transfer

C Unified Asynchronous Register Timer

D Universal Analog Receiver/Transmitter

UART stands for Universal Asynchronous Receiver/Transmitter.

In UART, what frames each byte of data?

A Start and stop bits

B Parity bits only

C Clock signal

D Data checksum

Start and stop bits frame each byte to mark the beginning and end in asynchronous communication.

What happens if you write to the UART data register before TXE is set?

A Data is sent twice

B Data may be lost or overwritten

C UART resets automatically

D Nothing happens

Writing before TXE is set can overwrite data that has not yet been transmitted, causing data loss.

Which of these is NOT part of UART transmission?

A Stop bit

B Start bit

C Data bits

D Synchronous clock signal

UART is asynchronous and does not use a synchronous clock signal.

Explain the steps to transmit a single byte over UART in embedded C.

Think about how to know when UART is ready and how to send the byte.

Describe why UART communication is called asynchronous and how it affects byte transmission.

Focus on timing and framing of data.

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