Why Do Microcontrollers Use Oversampling in UART?

UART communication is asynchronous.
That means the transmitter and receiver do not share the same clock. Each device runs using its own oscillator, which can have small timing differences.
So how does the receiver know exactly when to read each bit?
The answer is oversampling.
Instead of sampling the signal once per bit, most microcontrollers sample it 16 times during one bit period.
This allows the UART hardware to:
• Detect the start bit precisely
• Sample near the center of each bit (where the signal is most stable)
• Use multiple samples to filter noise
• Tolerate small clock mismatches between devices
For example, at 9600 baud, a typical UART receiver internally samples at:
9600 × 16 = 153600 samples per second
These extra samples help the receiver reconstruct the correct timing of each bit, making communication reliable even when clocks are not perfectly aligned.
Without oversampling, UART communication would be much more sensitive to noise and timing errors.
Oversampling is one of those small hardware techniques that quietly ensures robust serial communication in almost every microcontroller.
#EmbeddedSystems #Microcontrollers #UART #Firmware #EmbeddedEngineering #DigitalCommunication
#embedded_systems_world
#whyseries
Follow on LinkedIn

Comments

Post a Comment

Thanks for reading through the Embedded Systems World.
Feel free to ask questions or share your thoughts on the topic.

Popular posts from this blog

Why Do Microcontrollers Start with an Internal Oscillator?

Why Does a Microcontroller Start With an Internal Oscillator? When a microcontroller powers on, it needs one thing before it can execute even its first instruction: A clock. Most microcontrollers initially run from an internal oscillator. But if an external crystal is more accurate, why doesn't the microcontroller simply start with it? The answer comes down to startup speed, reliability, and initialization sequence. 1️⃣ Fast Startup Internal RC oscillators can become usable very quickly. External crystals need additional time for their oscillations to build and stabilize. Instead of waiting, the MCU can start executing firmware using its internal clock. Power ON → Internal Oscillator → CPU Starts Executing Meanwhile, the external clock source can be initialized and allowed to stabilize. 2️⃣ Guaranteed Availability The internal oscillator is built into the microcontroller. An external crystal depends on components outside the MCU, such as: • Crystal or resonator • Load capacitors • ...
Read more

Why Can’t Large Constants Always Fit Inside CPU Instructions?

In assembly, you often see instructions like: ADD R0, R0, #5 Here #5 is embedded directly inside the instruction. This is called Immediate Addressing. But what happens if we write the following C code? x = x + 100000; Instead of placing the value directly inside the instruction, the CPU may generate something like: LDR R1, =100000 ADD R0, R0, R1 Why can’t the processor simply execute: ADD R0, R0, #100000 The Reason: Instruction Size Is Limited Most ARM instructions are 32 bits wide. Those 32 bits must encode several pieces of information: the operation (ADD, SUB, MOV, etc.) the destination register the source register the immediate value Conceptually, the instruction looks like this: [ opcode | registers | immediate value ] Since the instruction must store multiple fields, only a limited number of bits remain for the constant. As a result, very large numbers cannot always fit directly inside the instruction. What Happens When the Constant Is Too Large? When the constant cannot be encod...
Read more

Why Does the Stack Usually Grow Downward?

Image
When debugging nested function calls, you may notice the Stack Pointer moving toward lower memory addresses as the call depth increases. For example: SP = 0x20001000 PUSH {R4} SP = 0x20000FFC But why does this happen? Is a downward-growing stack inherently better, or is it simply an architectural convention? 1. The Stack Does Not Have to Grow Downward A processor can support either: Descending stack: SP decreases as data is pushed. or: Ascending stack: SP increases as data is pushed. Both approaches can work efficiently. So the real question is: Why did descending stacks become so common? 2. It Fits Traditional Memory Layouts Well A simplified memory layout often looks like this: High Address +------------------+ | Stack | | ↓ | | | | Free RAM | | | | ↑ | | Heap | +------------------+ Low Address The stack can begin near the upper end of available memory and grow toward lower addr...
Read more