I2C and SPI Communication on ATmega328P

I2C (Inter-Integrated Circuit) and SPI (Serial Peripheral Interface) are two widely used communication protocols in embedded systems. They allow microcontrollers to communicate efficiently with peripherals such as sensors, EEPROMs, displays, and other microcontrollers. The ATmega328P has dedicated hardware modules for both I2C (TWI - Two Wire Interface) and SPI, enabling seamless data exchange.

Why Use I2C and SPI?

I2C: Supports multiple devices on the same two-wire bus, making it ideal for sensor networks and low-power applications.
SPI: Offers higher data transfer rates, making it useful for fast communication with memory chips, displays, and high-speed peripherals.

Understanding I2C (TWI) on ATmega328P

I2C is a synchronous, multi-master, multi-slave protocol that uses two wires:

SDA (Serial Data - PC4)
SCL (Serial Clock - PC5)

I2C devices communicate using a 7-bit or 10-bit address and support speeds up to 400kHz (Fast Mode). Multiple devices can share the same bus, with the master initiating communication.

I2C Data Transmission Process

Start Condition – The master pulls SDA low while SCL remains high.
Addressing – The master sends the 7-bit address of the slave, followed by a read/write bit.
ACK/NACK – The slave acknowledges (ACK) or not acknowledges (NACK) the address.
Data Transfer – The master or slave transmits data one byte at a time, acknowledging each byte received.
Stop Condition – The master releases both SDA and SCL lines, signaling the end of communication.

I2C Bus Arbitration

Since I2C allows multiple masters, arbitration is used to prevent conflicts when two masters attempt communication simultaneously. The master that maintains a low SDA signal wins arbitration and continues transmission.

Key I2C Registers:

Register	Description
TWBR	Bit rate register for controlling the SCL frequency
TWSR	Status register, indicating the state of I2C operations
TWDR	Data register for sending/receiving data
TWCR	Control register for enabling I2C operations and handling interrupts

Configuring ATmega328P as an I2C Master

The following code initializes I2C communication and writes data to a slave device.

#include <avr/io.h>
#define F_CPU 16000000UL
#define SCL_CLOCK 100000L

void I2C_init() {
    TWBR = ((F_CPU / SCL_CLOCK) - 16) / 2; // Set I2C clock frequency
}

void I2C_start() {
    TWCR = (1 << TWSTA) | (1 << TWEN) | (1 << TWINT);
    while (!(TWCR & (1 << TWINT))); // Wait for completion
}

void I2C_write(uint8_t data) {
    TWDR = data;
    TWCR = (1 << TWEN) | (1 << TWINT);
    while (!(TWCR & (1 << TWINT))); // Wait for completion
}

void I2C_stop() {
    TWCR = (1 << TWSTO) | (1 << TWEN) | (1 << TWINT);
}

int main() {
    I2C_init();
    I2C_start();
    I2C_write(0x50); // Write to slave device (e.g., EEPROM)
    I2C_write(0x00); // Send data byte
    I2C_stop();
    while (1);
}

Understanding SPI on ATmega328P

SPI is a full-duplex, master-slave protocol that operates using four lines:

MOSI (Master Out Slave In - PB3)
MISO (Master In Slave Out - PB4)
SCK (Serial Clock - PB5)
SS (Slave Select - PB2)

SPI allows higher data rates than I2C, making it ideal for high-speed data transfer applications.

SPI Communication Process

Master Selects Slave – The master pulls SS low.
Clock Synchronization – The master generates the clock signal on SCK.
Data Exchange – Data is shifted out via MOSI and in via MISO.
Slave Deselect – The master releases SS high.

Key SPI Registers:

Register	Description
SPCR	Control register, enables SPI and sets mode
SPSR	Status register, indicates SPI events
SPDR	Data register for SPI transmission

Configuring ATmega328P as an SPI Master

The following example configures ATmega328P as an SPI Master and sends data to a slave device.

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

void SPI_init() {
    DDRB |= (1 << PB3) | (1 << PB5) | (1 << PB2); // MOSI, SCK, and SS as outputs
    SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Enable SPI, Master mode, Clock F_CPU/16
}

void SPI_send(uint8_t data) {
    SPDR = data;
    while (!(SPSR & (1 << SPIF))); // Wait for transmission complete
}

int main() {
    SPI_init();
    while (1) {
        SPI_send(0x55); // Send data to SPI slave
        _delay_ms(500);
    }
}

I2C vs. SPI: When to Use Each

Feature	I2C	SPI
Wires Needed	2 (SDA, SCL)	4 (MOSI, MISO, SCK, SS)
Speed	Up to 400kHz	Up to several MHz
Multi-device Support	Yes (multi-master, multi-slave)	Yes (one master, multiple slaves)
Complexity	Higher (addressing, ACK/NACK)	Lower (direct data transfer)
Use Cases	Sensors, EEPROM, RTCs	Displays, SD cards, high-speed peripherals

Both I2C and SPI are powerful communication protocols that extend the capabilities of ATmega328P. While I2C is ideal for multiple-device networks, SPI offers faster data rates for high-performance peripherals. Understanding how to configure and use them will allow you to interface with a wide range of external devices in your embedded projects.

In the next post, we will explore external interrupts on ATmega328P, which allow event-driven execution for more efficient microcontroller operation. Stay tuned!