UART interrupt-driven communication in Embedded C

Introduction

UART interrupt-driven communication lets your microcontroller talk to other devices without waiting. It uses interrupts to handle data, so your program can do other things at the same time.

When you want to receive data from a sensor without stopping your program.

When sending data over UART and you don’t want to wait for each byte to finish.

When you need to handle incoming messages quickly and efficiently.

When your program has multiple tasks and can’t block on UART communication.

When you want to save power by letting the CPU sleep until data arrives.

Syntax

Embedded C

void UART_IRQHandler(void) {
    if (UART_Receive_Interrupt_Flag) {
        char received = UART_Read_Data();
        // Process received data
    }
    if (UART_Transmit_Interrupt_Flag) {
        if (more_data_to_send) {
            UART_Write_Data(next_byte);
        } else {
            Disable_Transmit_Interrupt();
        }
    }
}

The interrupt handler function name depends on your microcontroller and toolchain.

Inside the handler, check which UART interrupt happened (receive or transmit).

Examples

This example reads one byte when data arrives and stores it in a buffer.

Embedded C

void UART_IRQHandler(void) {
    if (UART_Receive_Interrupt_Flag) {
        char c = UART_Read_Data();
        buffer[index++] = c;
    }
}

This example sends bytes from a buffer one by one when the UART is ready to send.

Embedded C

void UART_IRQHandler(void) {
    if (UART_Transmit_Interrupt_Flag) {
        if (index < length) {
            UART_Write_Data(buffer[index++]);
        } else {
            Disable_Transmit_Interrupt();
        }
    }
}

Sample Program

This program simulates receiving 10 characters via UART using interrupts. The interrupt handler stores each character in a buffer. When the buffer is full, it prints the received characters.

Embedded C

#include <stdint.h>
#include <stdbool.h>

#define BUFFER_SIZE 10

volatile char rx_buffer[BUFFER_SIZE];
volatile uint8_t rx_index = 0;
volatile bool data_ready = false;

// Mock functions for UART hardware
bool UART_Receive_Interrupt_Flag = false;
char UART_Data_Register = 0;

char UART_Read_Data() {
    UART_Receive_Interrupt_Flag = false; // Clear flag
    return UART_Data_Register;
}

void UART_IRQHandler(void) {
    if (UART_Receive_Interrupt_Flag) {
        char c = UART_Read_Data();
        if (rx_index < BUFFER_SIZE) {
            rx_buffer[rx_index++] = c;
        }
        if (rx_index == BUFFER_SIZE) {
            data_ready = true;
        }
    }
}

int main(void) {
    // Simulate receiving data
    for (int i = 0; i < BUFFER_SIZE; i++) {
        UART_Data_Register = 'A' + i; // Letters A to J
        UART_Receive_Interrupt_Flag = true;
        UART_IRQHandler();
    }

    if (data_ready) {
        for (int i = 0; i < BUFFER_SIZE; i++) {
            // Print received data
            // In embedded, replace with actual output method
            // Here we use printf for demonstration
            printf("%c", rx_buffer[i]);
        }
        printf("\n");
    }
    return 0;
}

Important Notes

Interrupt-driven UART lets your program do other work while waiting for data.

Always clear the interrupt flag inside the handler to avoid repeated interrupts.

Make sure shared variables between main code and interrupt are declared volatile.

Summary

UART interrupt-driven communication uses interrupts to handle data without blocking.

It improves efficiency by letting the CPU do other tasks while waiting for UART data.

Interrupt handlers must check and clear interrupt flags and safely handle data.

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