Receiving a byte over UART in Embedded C - Deep Dive

Overview - Receiving a byte over UART

What is it?

Receiving a byte over UART means getting one piece of data sent from another device through a serial communication line. UART stands for Universal Asynchronous Receiver/Transmitter, which is a way computers and devices talk to each other one bit at a time without a shared clock. When a byte arrives, the UART hardware captures it and makes it available for the program to read. This process lets devices exchange information like text, commands, or sensor data.

Why it matters

Without receiving bytes over UART, devices like microcontrollers, sensors, or computers couldn't communicate simply and reliably over serial lines. This would make many embedded systems, like remote controls, GPS modules, or serial consoles, impossible or very complex. Receiving data byte-by-byte allows programs to react to incoming information immediately and keep devices in sync.

Where it fits

Before learning this, you should understand basic digital signals and how bits form bytes. After this, you can learn about UART transmission, interrupt-driven UART, and buffering techniques to handle continuous data streams efficiently.

Mental Model

Core Idea

Receiving a byte over UART is like catching a small package delivered bit by bit over a single wire, then opening it to see the message inside.

Think of it like...

Imagine a friend sending you a secret message by tapping on your shoulder one tap at a time. Each tap is a bit, and when all taps for one letter (byte) finish, you know the letter is complete and can understand the message.

┌───────────────┐
│ UART Receiver │
├───────────────┤
│ Bit 0 ───────▶│
│ Bit 1 ───────▶│
│ Bit 2 ───────▶│
│ Bit 3 ───────▶│
│ Bit 4 ───────▶│
│ Bit 5 ───────▶│
│ Bit 6 ───────▶│
│ Bit 7 ───────▶│
├───────────────┤
│ Byte Ready ▶ Program reads byte
└───────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding UART Basics

Concept: Learn what UART is and how it sends and receives bits asynchronously.

UART is a hardware communication protocol that sends data one bit at a time without a shared clock. It uses start bits, data bits, optional parity, and stop bits to frame each byte. The receiver watches the line for a start bit, then reads the data bits at timed intervals to reconstruct the byte.

Result

You know UART sends and receives data bit by bit framed by start and stop bits.

Understanding UART framing is essential because receiving a byte depends on detecting these bits correctly.

2

Foundation

Reading a Byte from UART Data Register

Concept: Learn how the UART hardware stores received bytes and how software reads them.

When UART hardware receives a full byte, it places it in a special register called the data register. The program reads this register to get the byte. For example, in embedded C, reading 'UARTx->DR' gives the received byte. The hardware also sets a flag to show data is ready.

Result

You can get the received byte by reading the UART data register.

Knowing the data register is the interface between hardware and software is key to receiving bytes.

3

Intermediate

Polling UART Receive Flag

🤔Before reading on: do you think the program waits passively or actively checks for data? Commit to your answer.

Concept: Learn how to check if a byte has arrived by polling a status flag.

The UART hardware sets a flag (like RXNE - Receive Not Empty) when a byte is ready. The program can repeatedly check this flag in a loop (polling). When the flag is set, the program reads the byte from the data register and clears the flag.

Result

The program successfully reads bytes only when they are ready, avoiding reading empty data.

Understanding polling helps grasp how software knows when to read data without missing bytes.

4

Intermediate

Using Interrupts for Byte Reception

🤔Before reading on: do you think interrupts make the CPU wait or free it for other tasks? Commit to your answer.

Concept: Learn how UART can notify the program automatically when a byte arrives using interrupts.

Instead of checking flags constantly, UART can trigger an interrupt when a byte arrives. The CPU pauses its current work, runs a special function (interrupt handler) to read the byte, then resumes. This is more efficient and allows multitasking.

Result

The program receives bytes immediately without wasting CPU time on polling.

Knowing interrupts improves efficiency and responsiveness in real embedded systems.

5

Advanced

Handling Buffer Overruns and Errors

🤔Before reading on: do you think UART hardware always receives bytes perfectly? Commit to your answer.

Concept: Learn about common problems like buffer overruns and framing errors during reception.

If the program doesn't read bytes fast enough, the UART buffer can overflow, losing data. Also, noise or timing issues can cause framing or parity errors. The UART hardware sets error flags, which the program must check and handle to ensure data integrity.

Result

The program can detect and recover from reception errors, improving reliability.

Understanding error handling prevents silent data loss and bugs in communication.

6

Expert

Optimizing Reception with DMA and Circular Buffers

🤔Before reading on: do you think CPU should always handle every byte or can hardware help? Commit to your answer.

Concept: Learn how Direct Memory Access (DMA) and circular buffers offload byte reception from the CPU.

DMA can transfer received bytes directly from UART hardware to memory without CPU intervention. Using a circular buffer, the program can process data in chunks asynchronously. This reduces CPU load and allows high-speed or continuous data reception without loss.

Result

The system handles large or fast data streams efficiently and reliably.

Knowing DMA and buffering techniques is crucial for professional embedded systems handling complex data flows.

Under the Hood

The UART receiver watches the serial line for a start bit, then samples the line at fixed intervals to read each data bit. It assembles these bits into a byte and stores it in a hardware data register. A status flag signals the program that data is ready. If interrupts are enabled, the hardware triggers an interrupt to alert the CPU. Internally, shift registers and timing circuits handle bit timing and framing.

Why designed this way?

UART was designed for simple, low-cost asynchronous serial communication without needing a shared clock line. Using start and stop bits allows the receiver to synchronize on each byte independently. The data register and flags provide a clean interface between hardware and software. Interrupts and DMA were added later to improve efficiency as embedded systems grew more complex.

┌───────────────┐
│ Serial Line   │
│  (Rx Pin)     │
└──────┬────────┘
       │ Start Bit Detected
       ▼
┌───────────────┐
│ Shift Register│
│ (Samples bits)│
└──────┬────────┘
       │ Byte Assembled
       ▼
┌───────────────┐
│ Data Register │◀───── UART Hardware
└──────┬────────┘      sets RXNE flag
       │
       ▼
┌───────────────┐
│ CPU / Program │
│ Reads Data    │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does reading the UART data register clear the receive flag automatically? Commit to yes or no.

Common Belief: Reading the UART data register does not affect the receive flag; you must clear it manually.

Reality: Reading the UART data register automatically clears the receive flag (RXNE) in most UART hardware.

Why it matters: If you don't read the data register, the flag stays set and new bytes may be lost or cause errors.

Quick: Can UART receive bytes without a start bit? Commit to yes or no.

Common Belief: UART can receive bytes even if the start bit is missing or corrupted.

Reality: The start bit is essential to synchronize the receiver; without it, the UART cannot correctly read the byte.

Why it matters: Ignoring start bits leads to framing errors and corrupted data reception.

Quick: Does enabling UART interrupts guarantee no data loss? Commit to yes or no.

Common Belief: Using UART interrupts means the CPU will never miss any received byte.

Reality: If the interrupt handler is too slow or disabled for too long, bytes can still be lost due to buffer overruns.

Why it matters: Assuming interrupts solve all reception problems can cause hidden bugs in high-speed or heavy-load systems.

Quick: Is polling always less efficient than interrupts? Commit to yes or no.

Common Belief: Polling UART receive flags is always inefficient compared to interrupts.

Reality: For very simple or low-speed applications, polling can be simpler and efficient enough without interrupt overhead.

Why it matters: Choosing interrupts unnecessarily can complicate code and increase power consumption in simple systems.

Expert Zone

1

Some UART hardware supports multi-byte FIFO buffers, reducing interrupt frequency and improving throughput.

2

Parity bits can be used not only for error detection but also for simple protocol signaling in some systems.

3

DMA reception requires careful buffer management to avoid overwriting unread data, especially with circular buffers.

When NOT to use

Receiving bytes over UART is not suitable for very high-speed or long-distance communication where protocols like SPI, I2C, or Ethernet are better. For complex data streams requiring error correction and framing, protocols like USB or CAN bus are preferred.

Production Patterns

In real embedded systems, UART reception often uses interrupt-driven or DMA-based circular buffers combined with state machines to parse protocols. Error flags are logged or trigger recovery routines. Low-power devices may disable UART or use wake-up interrupts to save energy.

Connections

Interrupt Handling

Builds-on

Understanding UART reception deeply connects to interrupt handling because interrupts allow immediate response to incoming data without wasting CPU cycles.

Buffer Management

Builds-on

Efficient UART reception depends on buffer management techniques like circular buffers to store incoming bytes safely before processing.

Human Communication

Analogy

Just like people listen for cues to know when someone starts speaking and then interpret words bit by bit, UART uses start bits and timing to receive data reliably.

Common Pitfalls

#1 Reading UART data register before data is ready

Wrong approach:

uint8_t data = UARTx->DR; // Read without checking flag

Correct approach:

while (!(UARTx->SR & RXNE_FLAG)) {} // Wait for data
uint8_t data = UARTx->DR; // Then read

Root cause:

Not checking the receive flag causes reading invalid or old data.

#2 Ignoring UART receive errors

Wrong approach:

uint8_t data = UARTx->DR; // Read without checking error flags

Correct approach:

if (UARTx->SR & (FE_FLAG | PE_FLAG | ORE_FLAG)) { handle_error(); }
uint8_t data = UARTx->DR;

Root cause:

Assuming all received data is error-free leads to corrupted communication.

#3 Disabling interrupts for too long during UART reception

Wrong approach:

Disable IRQs for long tasks, causing missed UART interrupts

Correct approach:

Keep interrupt disable time minimal; use flags or queues to defer processing

Root cause:

Long interrupt disable blocks UART interrupts, causing buffer overruns.

Key Takeaways

UART reception captures data bit by bit framed by start and stop bits to form bytes.

Reading the UART data register after checking the receive flag ensures valid data retrieval.

Interrupts and DMA improve efficiency by letting hardware notify or transfer data without constant CPU polling.

Handling errors and buffer overruns is essential for reliable UART communication.

Advanced techniques like circular buffers and DMA are key for professional embedded UART reception.