I2C Protocol Fundamentals

Basic Characteristics

• Developed by Philips in the 1980s
• Serial communication protocol
• Uses two wires: SDA (Serial Data) and SCL (Serial Clock)
• Supports multiple master and slave devices
• Low-speed communication (standard modes: 100 kbps, 400 kbps, high-speed modes up to 5 Mbps)

Protocol Structure

1. Physical Layer

• Two-wire communication
• Open-drain/open-collector architecture
• Requires pull-up resistors
• Devices can be masters or slaves
• Supports multiple devices on the same bus

2. Communication Mechanism

• Master initiates all communications
• Uses START and STOP conditions to control bus
• 7-bit or 10-bit addressing
• Data transferred in 8-bit packets
• Includes acknowledgment (ACK) bit after each byte

Communication Sequence

Copy1. START Condition
2. Slave Address (7/10 bit)
3. R/W Bit (Read/Write)
4. Acknowledgment
5. Data Transfer
6. STOP Condition

Detailed Communication Steps

1. START Condition

• SDA transitions from HIGH to LOW while SCL is HIGH
• Signals the beginning of communication

2. Address Phase

• Master sends slave address
• 7-bit address + 1 bit R/W
• Slaves compare address with their own

3. Acknowledgment

• Receiver pulls SDA LOW to acknowledge receipt
• Indicates successful data transfer

4. Data Transfer

• 8 bits transferred per packet
• Most significant bit sent first
• Alternates between master transmitting and receiving

Basic I2C Protocol Structure

Copy// Typical I2C communication structure
typedef struct {
    uint8_t device_address;  // 7-bit slave address
    uint8_t* data_buffer;    // Data buffer for transmission/reception
    uint16_t data_length;    // Length of data
} I2C_Transaction;

Core I2C Communication Sequence

// Simplified I2C communication flow
bool i2c_write(I2C_Transaction* transaction) {
    // Start Condition
    i2c_send_start();

    // Send Slave Address (Write Mode)
    i2c_send_address(transaction->device_address, WRITE_MODE);

    // Send Data Bytes
    for (int i = 0; i < transaction->data_length; i++) {
        if (!i2c_send_byte(transaction->data_buffer[i])) {
            // Handle transmission error
            i2c_send_stop();
            return false;
        }
        
        // Wait for Acknowledgement
        if (!i2c_wait_ack()) {
            i2c_send_stop();
            return false;
        }
    }

    // Stop Condition
    i2c_send_stop();
    return true;
}

Detailed Protocol Implementation

cCopy// Low-level I2C communication functions
void i2c_send_start() {
    // Pull SDA low while SCL is high
    // Indicates start of communication
    SET_SDA_LOW();
    SET_SCL_LOW();
}

void i2c_send_stop() {
    // Pull SDA high after pulling SCL high
    // Indicates end of communication
    SET_SDA_LOW();
    SET_SCL_HIGH();
    SET_SDA_HIGH();
}

bool i2c_send_byte(uint8_t data) {
    // Send 8 bits, most significant bit first
    for (int i = 7; i >= 0; i--) {
        // Set data bit
        if (data & (1 << i)) {
            SET_SDA_HIGH();
        } else {
            SET_SDA_LOW();
        }
        
        // Clock pulse
        SET_SCL_HIGH();
        SET_SCL_LOW();
    }
    return true;
}
bool i2c_wait_ack() {
    // Slave pulls SDA low to acknowledge
    SET_SDA_HIGH();  // Release SDA
    SET_SCL_HIGH();  // Clock high for acknowledgement
    
    // Check if slave pulled SDA low
    if (READ_SDA() == LOW) {
        SET_SCL_LOW();
        return true;
    }
    return false;
}

4. Advanced I2C Read Operation

Copybool i2c_read(I2C_Transaction* transaction) {
    // Start Condition
    i2c_send_start();

    // Send Slave Address (Read Mode)
    i2c_send_address(transaction->device_address, READ_MODE);

    // Receive Data Bytes
    for (int i = 0; i < transaction->data_length; i++) {
        transaction->data_buffer[i] = i2c_read_byte();
        
        // Send Acknowledgement for all bytes except last
        if (i < transaction->data_length - 1) {
            i2c_send_ack();
        } else {
            // Send NACK for last byte
            i2c_send_nack();
        }
    }

    // Stop Condition
    i2c_send_stop();
    return true;
}

5. Addressing Modes

// I2C Addressing
#define GENERAL_CALL_ADDRESS 0x00
#define WRITE_MODE 0
#define READ_MODE  1

void i2c_send_address(uint8_t address, bool read_mode) {
    // Combine 7-bit address with R/W bit
    uint8_t full_address = (address << 1) | read_mode;
    i2c_send_byte(full_address);
}

6. Error Handling and Arbitration

typedef enum {
    I2C_NO_ERROR,
    I2C_TIMEOUT,
    I2C_NACK_ERROR,
    I2C_BUS_BUSY
} I2C_Error;

I2C_Error i2c_master_transfer(I2C_Transaction* transaction) {
    // Check bus availability
    if (i2c_is_bus_busy()) {
        return I2C_BUS_BUSY;
    }

    // Perform transaction with error checking
    if (!i2c_write(transaction)) {
        return I2C_NACK_ERROR;
    }

    return I2C_NO_ERROR;
}

Key Protocol Characteristics:

1. Serial Communication
   • Uses two lines: SDA (data) and SCL (clock)
   • Synchronous communication
   • Half-duplex mode
2. Addressing Mechanism
   • 7-bit or 10-bit addressing
   • Supports multiple masters and slaves
   • Each slave has a unique address
3. Communication Phases
   • Start Condition
   • Address Transmission
   • Data Transfer
   • Acknowledgement
   • Stop Condition
4. Timing Considerations
   • Standard Mode: 100 Kbps
   • Fast Mode: 400 Kbps
   • High-Speed Mode: 3.4 Mbps

Practical Considerations:

• Use pull-up resistors on SDA and SCL lines
• Implement timeout mechanisms
• Check bus availability before transmission
• Handle potential bus contention

Common Use Cases:

• Sensor interfaces
• EEPROM communication
• Real-time clock modules
• Low-speed peripheral communication

Limitations:

• Limited bandwidth compared to SPI
• More complex protocol overhead
• Potential for bus contention with multiple masters

Sample Device Interaction:

// Example: Reading temperature from I2C sensor
I2C_Transaction temp_sensor = {
    .device_address = 0x48,  // Example sensor address
    .data_buffer = temperature_data,
    .data_length = 2
};

if (i2c_read(&temp_sensor) == I2C_NO_ERROR) {
    // Process temperature data
    process_temperature(temperature_data);
}

Debugging Tips:

• Use logic analyzers to view I2C communication
• Implement detailed error logging
• Verify timings and acknowledgement sequences

This comprehensive overview covers the programmatic implementation of the I2C protocol, highlighting its core mechanisms, communication flow, and practical considerations.