Receiving a byte over UART in Embedded C

Introduction

Receiving a byte over UART lets your microcontroller get data from another device. This is useful to read commands or information sent to your system.

When you want to read a character sent from a computer to your microcontroller.

When your device needs to receive sensor data from another module via UART.

When you want to get user input from a serial terminal.

When communicating between two microcontrollers using UART.

When debugging by receiving messages from another device.

Syntax

Embedded C

uint8_t received_byte = UART_Receive();

UART_Receive() is a placeholder function that reads one byte from UART.

Usually, you wait until data is available before reading to avoid errors.

Examples

Read one byte from UART and store it in data.

Embedded C

uint8_t data = UART_Receive();

Wait until data is ready, then read one byte.

Embedded C

while(!UART_DataAvailable()) {
    // wait for data
}
uint8_t data = UART_Receive();

Check if data is available before reading to avoid blocking.

Embedded C

if(UART_DataAvailable()) {
    uint8_t data = UART_Receive();
    // process data
}

Sample Program

This program simulates receiving a byte 'A' over UART. It waits until data is ready, reads it, then prints the character.

Embedded C

#include <stdint.h>
#include <stdio.h>

// Simulated UART registers and functions for example
volatile uint8_t UART_DR = 0; // Data register
volatile uint8_t UART_SR = 0; // Status register

#define UART_SR_RXNE (1 << 5) // Receive data register not empty flag

// Function to simulate data arrival
void UART_SimulateReceive(uint8_t byte) {
    UART_DR = byte;
    UART_SR |= UART_SR_RXNE; // Set data ready flag
}

// Check if data is available
int UART_DataAvailable() {
    return (UART_SR & UART_SR_RXNE) != 0;
}

// Receive one byte
uint8_t UART_Receive() {
    while(!UART_DataAvailable()) {
        // wait for data
    }
    uint8_t byte = UART_DR;
    UART_SR &= ~UART_SR_RXNE; // Clear data ready flag
    return byte;
}

int main() {
    // Simulate receiving the letter 'A'
    UART_SimulateReceive('A');

    uint8_t received = UART_Receive();
    printf("Received byte: %c\n", received);
    return 0;
}

Important Notes

UART data is usually read from a hardware register when a flag shows data is ready.

Always check if data is available before reading to avoid blocking or errors.

In real hardware, UART registers and flags depend on your microcontroller model.

Summary

Receiving a byte over UART means reading one character sent from another device.

Check if data is available before reading to avoid waiting forever.

Use a function or register to get the byte and then process it as needed.