UART Communication on ATmega328P

UART (Universal Asynchronous Receiver-Transmitter) is one of the most fundamental communication protocols used in embedded systems. The ATmega328P has a built-in USART (Universal Synchronous and Asynchronous Serial Receiver and Transmitter) module, allowing seamless serial communication with a PC via a USB-to-TTL converter (e.g., CP2102, CH340, or FTDI).

Why Use UART?

• Debugging: Easily send logs to a terminal.
• Data Exchange: Communicate between microcontrollers and computers.
• Interfacing with Modules: Many peripherals (GPS, Bluetooth, GSM) use UART.
• Low Overhead: Unlike I2C or SPI, UART does not require clock synchronization.

Understanding UART in ATmega328P

The ATmega328P has one hardware UART (USART0), which supports both synchronous and asynchronous serial communication. On the Arduino Uno, this hardware UART (USART0) is used for USB-to-PC communication through an onboard USB-to-serial converter (such as the ATmega16U2 chip). This allows the Arduino to interface with the Serial Monitor on a computer while also enabling firmware uploads.

UART communication consists of TX (Transmit) and RX (Receive) lines operating asynchronously at a specific baud rate (bits per second). Common baud rates include 9600, 115200, etc.

UART Frame Structure

Each UART frame consists of:

• Start Bit (1-bit) – Indicates the beginning of transmission.
• Data Bits (5-9 bits) – Represents the actual transmitted data.
• Parity Bit (Optional) – Used for error detection.
• Stop Bit (1-2 bits) – Marks the end of transmission.

ATmega328P USART Registers

The USART module in ATmega328P is controlled using several registers:

Setting Up UART on ATmega328P

Step 1: Circuit Connections

• TX (PD1) → RX of USB-to-TTL module
• RX (PD0) → TX of USB-to-TTL module
• GND → GND of USB-to-TTL module

Step 2: Configuring UART in C

The following program initializes UART communication at 9600 baud and sends a message to the terminal.

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>

void UART_init(unsigned int baud) {
    unsigned int ubrr = F_CPU / 16 / baud - 1;
    UBRR0H = (ubrr >> 8);
    UBRR0L = ubrr;
    UCSR0B = (1 << TXEN0) | (1 << RXEN0); // Enable TX and RX
    UCSR0C = (1 << UCSZ01) | (1 << UCSZ00); // 8-bit data, 1 stop bit
}

void UART_sendChar(char data) {
    while (!(UCSR0A & (1 << UDRE0))); // Wait for transmit buffer to be empty
    UDR0 = data;
}

void UART_sendString(const char *str) {
    while (*str) {
        UART_sendChar(*str++);
    }
}

int main() {
    UART_init(9600);
    while (1) {
        UART_sendString("Hello, UART!\r\n");
        _delay_ms(1000);
    }
}

Step 3: Receiving Data from UART

To receive data, modify the code as follows:

char UART_receiveChar() {
    while (!(UCSR0A & (1 << RXC0))); // Wait for received data
    return UDR0;
}

int main() {
    UART_init(9600);
    char received;
    while (1) {
        received = UART_receiveChar();
        UART_sendChar(received); // Echo back received character
    }
}

Step 4: Interfacing with a PC Terminal

• Use Putty, RealTerm, or Arduino Serial Monitor.
• Select the correct COM port and 9600 baud rate.
• You should see “Hello, UART!” printed every second.

Step 5: Interrupt-Based UART Reception

Instead of polling, use UART interrupts to receive data efficiently:

ISR(USART_RX_vect) {
    char received = UDR0;
    UART_sendChar(received); // Echo received character
}

int main() {
    UART_init(9600);
    UCSR0B |= (1 << RXCIE0); // Enable RX complete interrupt
    sei(); // Enable global interrupts
    while (1) {}
}

UART is an essential feature for communication in embedded systems. By configuring ATmega328P’s USART module, we can enable seamless serial data exchange with a PC or other devices. Using interrupts improves efficiency, making it ideal for real-time applications.

In the next post, we will explore I2C and SPI communication, allowing ATmega328P to interface with sensors and memory devices. Stay tuned!