UART protocol fundamentals in Embedded C - Step-by-Step Execution

Concept Flow - UART protocol fundamentals

Idle Line

↓

Start Bit Detected

↓

Read Data Bits (usually 8)

↓

Check Parity Bit (optional)

↓

Read Stop Bit(s)

↓

Frame Complete -> Data Ready

↓

Back to Idle Line

UART communication starts with an idle line, detects a start bit, reads data bits, optional parity, stop bits, then completes the frame and returns to idle.

Execution Sample

Embedded C

void uart_receive() {
  if (start_bit_detected()) {
    uint8_t data = read_8_bits();
    if (check_parity(data)) {
      process_data(data);
    }
  }
}

This code waits for a start bit, reads 8 data bits, checks parity, and processes the data if parity is correct.

Execution Table

Step	Signal Detected	Action	Data Value	Status
1	Idle line (high)	Wait for start bit	-	Waiting
2	Start bit (low)	Start reading data bits	-	Start bit detected
3	Data bit 0	Read bit	1	Reading data
4	Data bit 1	Read bit	0	Reading data
5	Data bit 2	Read bit	1	Reading data
6	Data bit 3	Read bit	1	Reading data
7	Data bit 4	Read bit	0	Reading data
8	Data bit 5	Read bit	0	Reading data
9	Data bit 6	Read bit	1	Reading data
10	Data bit 7	Read bit	0	Reading data
11	Parity bit	Check parity	-	Parity OK
12	Stop bit (high)	Frame complete	0b01011001	Data ready
13	Idle line	Wait for next start bit	-	Waiting

💡 Stop bit received and parity checked, frame complete, ready for next frame.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	After Step 9	After Step 10	Final
data_bits	-	1	10	101	1011	10110	101100	1011001	10110010	0b01011001

Key Moments - 3 Insights

Why does UART start with a low start bit instead of high?

The start bit is low to signal the beginning of data transmission clearly because the idle line is high; this contrast helps the receiver detect the start (see execution_table step 2).

What happens if parity check fails?

If parity fails, the data is considered corrupted and usually discarded or flagged; in the example, process_data() is only called if parity is OK (see execution_table step 11).

Why do we read data bits one by one instead of all at once?

UART sends bits serially over one wire, so the receiver reads each bit in sequence to reconstruct the byte (see variable_tracker showing bits accumulating step by step).

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the data_bits value after reading data bit 2?

A 101

B 10

C 1

D 0

💡 Hint

Check the 'Data Value' and 'Action' columns at step 5 in execution_table.

At which step does the UART frame become ready for processing?

A Step 11

B Step 12

C Step 10

D Step 13

💡 Hint

Look for 'Frame complete' and 'Data ready' status in execution_table.

If the parity bit was incorrect, what would change in the execution flow?

A Data bits would be skipped

B Start bit would be ignored

C process_data() would not be called

D Stop bit would be read twice

💡 Hint

Refer to key_moments about parity check and execution_table step 11.

Concept Snapshot

UART sends data serially with:
- Idle line high
- Start bit low to begin
- 8 data bits sent one by one
- Optional parity bit for error check
- Stop bit(s) high to end frame
Receiver detects start, reads bits, checks parity, then processes data.

Full Transcript

UART protocol works by keeping the line idle high. When data is sent, a low start bit signals the beginning. Then 8 data bits are sent one after another. Optionally, a parity bit is sent to check errors. Finally, stop bit(s) high mark the end of the frame. The receiver watches the line, detects the start bit, reads each data bit in order, checks parity, and when the stop bit arrives, the data is ready to use. This step-by-step process ensures reliable serial communication.

Practice

1. What does UART stand for in embedded systems communication?

easy

A. Universal Analog Radio Transmitter

B. Universal Automatic Register Transfer

C. Unified Asynchronous Remote Terminal

D. Universal Asynchronous Receiver/Transmitter

Solution

1. Step 1: Understand UART acronym

   UART is a communication protocol used in embedded systems for serial communication.

2. Step 2: Match full form

   UART stands for Universal Asynchronous Receiver/Transmitter, describing its function.

3. Final Answer:

   Universal Asynchronous Receiver/Transmitter -> Option D

4. Quick Check:

   UART = Universal Asynchronous Receiver/Transmitter [OK]

Hint: Remember UART is about asynchronous serial communication [OK]

Common Mistakes:

• Confusing UART with synchronous protocols
• Mixing up the acronym words
• Thinking UART is analog communication

2. Which of the following is the correct way to initialize UART in embedded C?

easy

A. uart_init(9600);

B. UART_Init(baudrate=9600);

C. uartStart(9600);

D. init_uart(9600);

Solution

1. Step 1: Identify common UART init function

   In embedded C, uart_init with baud rate parameter is a common initialization call.

2. Step 2: Check syntax correctness

   uart_init(9600); uses correct function name and parameter style without extra keywords.

3. Final Answer:

   uart_init(9600); -> Option A

4. Quick Check:

   Correct UART init syntax = uart_init(9600); [OK]

Hint: Look for simple function call with baud rate only [OK]

Common Mistakes:

• Using incorrect function names
• Adding parameter names inside call
• Using camelCase instead of snake_case

3. What will be the output of this UART send code snippet?

uart_init(9600);
uart_send_char('A');
uart_send_char('B');

medium

A. BA

B. A B

C. AB

D. Error: uart_send_char undefined

Solution

1. Step 1: Initialize UART at 9600 baud

   The uart_init(9600) sets baud rate for communication.

2. Step 2: Send characters in order

   uart_send_char('A') sends 'A', then uart_send_char('B') sends 'B' sequentially.

3. Final Answer:

   AB -> Option C

4. Quick Check:

   Characters sent in order = AB [OK]

Hint: Characters send in call order, no spaces added [OK]

Common Mistakes:

• Assuming characters reverse order
• Expecting spaces between characters
• Thinking uart_send_char is undefined

4. Identify the error in this UART initialization code:

void setup() {
  uart_init(115200);
  uart_init(9600);
}

medium

A. uart_init requires no parameters

B. Multiple uart_init calls cause baud rate conflict

C. Function name should be UART_Init

D. No error, code is correct

Solution

1. Step 1: Review uart_init calls

   Two uart_init calls with different baud rates cause conflict in configuration.

2. Step 2: Understand UART config rules

   UART baud rate must be set once before communication; multiple calls overwrite settings.

3. Final Answer:

   Multiple uart_init calls cause baud rate conflict -> Option B

4. Quick Check:

   Multiple init calls cause conflict = A [OK]

Hint: Only one uart_init call needed to set baud rate [OK]

Common Mistakes:

• Thinking multiple init calls are allowed
• Assuming uart_init has no parameters
• Ignoring case sensitivity in function names

5. You want to send the string "HELLO" over UART. Which code snippet correctly sends each character one by one?

hard

A. for(int i=0; i<5; i++) uart_send_char("HELLO"[i]);

B. for(int i=0; i<5; i++) uart_send_char('H' + i);

C. for(int i=0; i<5; i++) uart_send_char('HELLO'[i]);

D. for(int i=0; i<5; i++) uart_send_char("HELLO" + i);

Solution

1. Step 1: Understand string indexing in C

   In C, single quotes ' ' denote characters, double quotes \" \" denote strings (char arrays).

2. Step 2: Check each option for correct character access

   for(int i=0; i<5; i++) uart_send_char(\"HELLO\"[i]); correctly indexes the string literal to access each character 'H','E','L','L','O'.

3. Final Answer:

   for(int i=0; i<5; i++) uart_send_char("HELLO"[i]); -> Option A

4. Quick Check:

   Correct string indexing uses double quotes \"HELLO\"[i] [OK]

Hint: Use double quotes for string literal indexing in C [OK]

Common Mistakes:

• Using single quotes for multi-character string literals
• Adding integers to characters ('H' + i sends HIJKL)
• Using pointer arithmetic without dereferencing