Transmitting a byte over UART in Embedded C

Introduction

We send data one byte at a time using UART to communicate between devices like microcontrollers and computers.

Sending sensor data from a microcontroller to a computer for monitoring.

Controlling a robot by sending commands from a remote controller.

Debugging a program by sending messages to a serial console.

Communicating between two microcontrollers in a project.

Syntax

Embedded C

void UART_Transmit(unsigned char data) {
    while (!(UART_STATUS_REGISTER & TRANSMIT_READY_FLAG)) {
        // wait until UART is ready to send
    }
    UART_DATA_REGISTER = data;
}

The function waits until the UART hardware is ready before sending the byte.

Replace UART_STATUS_REGISTER, TRANSMIT_READY_FLAG, and UART_DATA_REGISTER with your device's specific register names.

Examples

Sends the character 'A' over UART.

Embedded C

UART_Transmit('A');

Sends the byte 0x55 (binary 01010101) over UART.

Embedded C

unsigned char value = 0x55;
UART_Transmit(value);

Sample Program

This program simulates sending two characters 'H' and 'i' over UART. It waits for UART to be ready before sending each byte.

Embedded C

#include <stdint.h>
#include <stdbool.h>

// Mock UART registers for example
volatile uint8_t UART_STATUS_REGISTER = 0x02; // Bit 1 means ready
volatile uint8_t UART_DATA_REGISTER = 0;
#define TRANSMIT_READY_FLAG 0x02

void UART_Transmit(uint8_t data) {
    while (!(UART_STATUS_REGISTER & TRANSMIT_READY_FLAG)) {
        // wait until UART is ready
    }
    UART_DATA_REGISTER = data;
    // Simulate UART busy after sending
    UART_STATUS_REGISTER &= ~TRANSMIT_READY_FLAG;
}

int main() {
    // Simulate UART ready
    UART_STATUS_REGISTER = TRANSMIT_READY_FLAG;

    UART_Transmit('H');
    UART_STATUS_REGISTER = TRANSMIT_READY_FLAG; // Ready again
    UART_Transmit('i');

    // For demonstration, print what was sent
    // In real embedded, you can't print like this
    // Here we just show the last byte sent
    return UART_DATA_REGISTER;
}

Important Notes

UART transmission is usually slow compared to CPU speed, so waiting for ready is important.

Registers and flags differ by microcontroller, always check your device datasheet.

In real embedded systems, you often use interrupts or DMA for efficient UART transmission.

Summary

UART sends data one byte at a time using hardware registers.

Always wait until UART is ready before sending a byte.

Use your microcontroller's datasheet to find correct register names and flags.

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