UART interrupt-driven communication in Embedded C - Mini Project: Build & Apply

UART Interrupt-Driven Communication

📖 Scenario: You are working on a small embedded system that communicates with a sensor using UART (Universal Asynchronous Receiver/Transmitter). To efficiently receive data without constantly checking the UART status, you will use interrupt-driven communication.This means the microcontroller will automatically call a special function (interrupt handler) when new data arrives, so your program can respond immediately.

🎯 Goal: Build a simple UART interrupt-driven communication program that receives characters from the sensor and stores them in a buffer.You will create the UART data buffer, configure the interrupt flag, write the interrupt handler to read incoming data, and finally print the received data.

📋 What You'll Learn

Create a character array buffer called uart_buffer with size 10

Create an integer variable buffer_index to track the buffer position

Create a variable uart_interrupt_flag to simulate the UART interrupt flag

Write an interrupt handler function UART_ISR that reads a character from uart_data_register and stores it in uart_buffer at buffer_index, then increments buffer_index

Reset uart_interrupt_flag inside the interrupt handler

Simulate receiving 3 characters by setting uart_data_register and uart_interrupt_flag, then calling UART_ISR each time

Print the contents of uart_buffer after receiving the characters

💡 Why This Matters

🌍 Real World

UART interrupt-driven communication is used in embedded devices like sensors, GPS modules, and serial communication between microcontrollers to efficiently receive data without wasting CPU time.

💼 Career

Understanding UART interrupts is essential for embedded systems engineers and firmware developers working on real-time communication and device drivers.

1

Create UART buffer and index

Create a character array called uart_buffer with size 10 and an integer variable called buffer_index initialized to 0.

Embedded C

# Create uart_buffer array and buffer_index variable
# Your code here

Hint

Think of uart_buffer as a small box to hold characters, and buffer_index as a marker showing where to put the next character.

2

Create UART interrupt flag and data register

Create an integer variable called uart_interrupt_flag initialized to 0 and a character variable called uart_data_register to simulate incoming UART data.

Embedded C

char uart_buffer[10];
int buffer_index = 0;

// Create uart_interrupt_flag and uart_data_register
// Your code here

Hint

The uart_interrupt_flag tells us when new data arrives. The uart_data_register holds the incoming character.

3

Write UART interrupt service routine

Write a function called UART_ISR that checks if uart_interrupt_flag is 1. If yes, it stores uart_data_register into uart_buffer at buffer_index, increments buffer_index, and resets uart_interrupt_flag to 0.

Embedded C

char uart_buffer[10];
int buffer_index = 0;

int uart_interrupt_flag = 0;
char uart_data_register;

// Write UART_ISR function
// Your code here

Hint

This function acts like a helper that runs automatically when data arrives. It saves the data and clears the flag.

4

Simulate receiving data and print buffer

Simulate receiving characters 'A', 'B', and 'C' by setting uart_data_register to each character, setting uart_interrupt_flag to 1, and calling UART_ISR() each time. Then print the contents of uart_buffer as a string.

Embedded C

char uart_buffer[10];
int buffer_index = 0;

int uart_interrupt_flag = 0;
char uart_data_register;

void UART_ISR() {
    if (uart_interrupt_flag == 1) {
        uart_buffer[buffer_index] = uart_data_register;
        buffer_index++;
        uart_interrupt_flag = 0;
    }
}

// Simulate receiving 'A', 'B', 'C' and print uart_buffer
// Your code here

Hint

Think of this as the sensor sending three letters one by one. Each time, the interrupt handler saves the letter. Finally, we print all saved letters.

Practice

1. What is the main advantage of using UART interrupt-driven communication in embedded systems?

easy

A. It allows the CPU to perform other tasks while waiting for UART data.

B. It requires the CPU to constantly check the UART status manually.

C. It disables all other interrupts during UART communication.

D. It slows down data transmission to avoid errors.

Solution

1. Step 1: Understand UART polling vs interrupt

   Polling requires CPU to wait and check UART status repeatedly, wasting time.

2. Step 2: Identify interrupt-driven benefit

   Interrupt-driven UART lets CPU do other work and only handles UART when data arrives.

3. Final Answer:

   It allows the CPU to perform other tasks while waiting for UART data. -> Option A

4. Quick Check:

   Interrupt-driven = CPU multitasks [OK]

Hint: Interrupts free CPU from waiting, improving multitasking [OK]

Common Mistakes:

• Confusing polling with interrupt-driven method
• Thinking interrupts disable other tasks
• Assuming interrupt slows communication

2. Which of the following is the correct way to enable UART receive interrupt in embedded C?

easy

A. UART->CR1 &= ~UART_CR1_RXNEIE;

B. UART->CR1 = 0;

C. UART->CR1 |= UART_CR1_RXNEIE;

D. UART->CR1 |= UART_CR1_TXEIE;

Solution

1. Step 1: Identify RX interrupt enable bit

   UART_CR1_RXNEIE enables receive-not-empty interrupt.

2. Step 2: Enable RX interrupt without clearing other bits

   Use bitwise OR (|=) to set RXNEIE bit.

3. Final Answer:

   UART->CR1 |= UART_CR1_RXNEIE; -> Option C

4. Quick Check:

   Enable RX interrupt = |= UART_CR1_RXNEIE [OK]

Hint: Use |= to set interrupt enable bits without clearing others [OK]

Common Mistakes:

• Using &= ~ to enable instead of disable bits
• Setting TX interrupt instead of RX
• Overwriting CR1 register instead of OR-ing

3. Given this UART interrupt handler code snippet, what will be the output if a byte 'A' (0x41) is received?

void USART1_IRQHandler(void) {
  if (USART1->SR & USART_SR_RXNE) {
    char data = USART1->DR;
    USART1->DR = data + 1;
  }
}

medium

A. The UART sends back 'A' unchanged.

B. The UART sends back 'B' (0x42) after receiving 'A'.

C. The UART sends back 'C' (0x43) after receiving 'A'.

D. No data is sent back.

Solution

1. Step 1: Read received data

   Data 'A' (0x41) is read from USART1->DR.

2. Step 2: Write back data + 1

   Data + 1 = 0x41 + 1 = 0x42, which is 'B'.

3. Final Answer:

   The UART sends back 'B' (0x42) after receiving 'A'. -> Option B

4. Quick Check:

   Received 'A' + 1 = 'B' [OK]

Hint: Adding 1 to 'A' (0x41) gives 'B' (0x42) [OK]

Common Mistakes:

• Confusing ASCII values and characters
• Assuming data is unchanged
• Ignoring the addition operation

4. Identify the bug in this UART interrupt handler code:

void USART2_IRQHandler(void) {
  if (USART2->SR & USART_SR_TXE) {
    USART2->DR = tx_buffer[tx_index++];
  }
  USART2->SR &= ~USART_SR_TXE;
}

medium

A. The USART2->DR register should not be written inside the interrupt.

B. The interrupt handler should clear RXNE flag instead of TXE.

C. The tx_index variable is not incremented correctly.

D. Clearing the TXE flag manually is incorrect; it is cleared by hardware.

Solution

1. Step 1: Understand TXE flag behavior

   TXE (transmit data register empty) flag is cleared automatically by hardware when data is written to DR.

2. Step 2: Identify incorrect manual clearing

   Code tries to clear TXE by writing to SR register, which is read-only or managed by hardware.

3. Final Answer:

   Clearing the TXE flag manually is incorrect; it is cleared by hardware. -> Option D

4. Quick Check:

   TXE flag cleared by hardware, not software [OK]

Hint: TXE flag clears automatically; don't clear it manually [OK]

Common Mistakes:

• Trying to clear hardware-managed flags manually
• Confusing TXE and RXNE flags
• Not incrementing buffer index properly

5. You want to implement a UART interrupt-driven echo program that receives data and immediately sends it back. Which sequence of actions should the interrupt handler perform to work correctly and efficiently?

hard

A. Check RXNE flag, read data from DR, write data back to DR, do not clear RXNE flag manually.

B. Clear RXNE flag manually, read data from DR, write data back to DR, check TXE flag.

C. Check TXE flag, write data to DR, clear TXE flag manually, then read data from DR.

D. Check RXNE flag, read data from DR, write data back to DR, clear RXNE flag manually.

Solution

1. Step 1: Handle RXNE flag correctly

   Check RXNE flag to know data received; read data from DR clears RXNE automatically.

2. Step 2: Write data back without manual flag clearing

   Write data to DR to send; TXE flag is managed by hardware, no manual clearing needed.

3. Final Answer:

   Check RXNE flag, read data from DR, write data back to DR, do not clear RXNE flag manually. -> Option A

4. Quick Check:

   Read clears RXNE; no manual flag clearing needed [OK]

Hint: Read clears RXNE; hardware manages flags automatically [OK]

Common Mistakes:

• Manually clearing RXNE or TXE flags
• Checking TXE before reading RXNE
• Writing data before reading received byte