Receiving a byte over UART in Embedded C - Mini Project: Build & Apply

Receiving a byte over UART

📖 Scenario: You are working on a small embedded device that communicates with other devices using UART (Universal Asynchronous Receiver/Transmitter). Your task is to write a simple program that receives one byte of data from the UART interface.

🎯 Goal: Build a program that sets up a variable to store the received byte, waits for the UART to have data ready, reads the byte from the UART data register, and then prints the received byte value.

📋 What You'll Learn

Create a variable to store the received byte

Create a variable to check the UART status register

Use a loop to wait until the UART receive buffer is full

Read the received byte from the UART data register

Print the received byte value

💡 Why This Matters

🌍 Real World

Embedded devices often communicate with sensors, other microcontrollers, or computers using UART. Receiving data correctly is essential for these devices to work.

💼 Career

Understanding UART communication is important for embedded systems engineers, firmware developers, and anyone working with microcontrollers.

1

DATA SETUP: Create a variable to store the received byte

Create a variable called received_byte of type unsigned char and initialize it to 0.

Embedded C

unsigned char received_byte = 0;  // Your code here

Hint

Use unsigned char to store one byte of data.

2

CONFIGURATION: Create a variable to check UART status

Create a variable called uart_status of type unsigned char to hold the UART status register value.

Embedded C

unsigned char received_byte = 0;
unsigned char uart_status;  // Your code here

Hint

This variable will be used to check if data is ready to read.

3

CORE LOGIC: Wait for data and read the byte from UART

Use a do-while loop to repeatedly read uart_status from UCSRA register and check if bit 7 (RXC) is set. When set, read the received byte from UDR register into received_byte.

Embedded C

unsigned char received_byte = 0;
unsigned char uart_status;

// Your code here

Hint

Bit 7 (RXC) in UCSRA tells if data is ready. Use bitwise AND to check it.

4

OUTPUT: Print the received byte value

Use printf to print the text "Received byte: " followed by the value of received_byte as an unsigned integer.

Embedded C

unsigned char received_byte = 0;
unsigned char uart_status;

do {
    uart_status = UCSRA;
} while ((uart_status & (1 << 7)) == 0);

received_byte = UDR;

// Your code here

Hint

Use printf("Received byte: %u\n", received_byte); to show the value.

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