Reading data from I2C device in Embedded C

Introduction

Reading data from an I2C device lets your microcontroller get information from sensors or other hardware. It helps your program understand the outside world.

You want to get temperature readings from a sensor connected via I2C.

You need to read data from an EEPROM chip to retrieve stored information.

You want to get the current time from a real-time clock module using I2C.

You want to read joystick or button states from an I2C input device.

Syntax

Embedded C

int i2c_read(uint8_t device_address, uint8_t register_address, uint8_t *data, size_t length);

// device_address: I2C address of the device
// register_address: Register to read from
// data: Pointer to buffer to store read bytes
// length: Number of bytes to read
// Returns 0 on success, non-zero on failure

The function usually returns 0 if reading was successful.

You must provide a buffer to store the data read from the device.

Examples

This reads 2 bytes from register 0x00 of the device at address 0x48.

Embedded C

uint8_t buffer[2];
int status = i2c_read(0x48, 0x00, buffer, 2);

This reads 1 byte from register 0x0F of the device at address 0x68.

Embedded C

uint8_t data;
int status = i2c_read(0x68, 0x0F, &data, 1);

Sample Program

This program simulates reading 3 bytes from an I2C device at address 0x50, register 0x10. It prints the bytes in hexadecimal format.

Embedded C

#include <stdio.h>
#include <stdint.h>
#include <string.h>

// Mock I2C read function for demonstration
int i2c_read(uint8_t device_address, uint8_t register_address, uint8_t *data, size_t length) {
    // For demo, pretend device returns fixed data
    if (device_address == 0x50 && register_address == 0x10 && length == 3) {
        data[0] = 0xAB;
        data[1] = 0xCD;
        data[2] = 0xEF;
        return 0; // success
    }
    return -1; // failure
}

int main() {
    uint8_t device_addr = 0x50;
    uint8_t reg_addr = 0x10;
    uint8_t read_data[3];

    int result = i2c_read(device_addr, reg_addr, read_data, sizeof(read_data));

    if (result == 0) {
        printf("Read data: 0x%02X 0x%02X 0x%02X\n", read_data[0], read_data[1], read_data[2]);
    } else {
        printf("Failed to read from device\n");
    }

    return 0;
}

Important Notes

Always check the return value of the I2C read function to handle errors.

Make sure the buffer you provide is large enough for the number of bytes you want to read.

Device addresses and register addresses are usually given in the device datasheet.

Summary

Reading data from I2C devices lets your program get sensor or hardware info.

You provide the device address, register, and a buffer to store data.

Always check if the read was successful before using the data.

Practice

1. What is the main purpose of reading data from an I2C device in embedded C?

easy

A. To send commands to the device only

B. To get sensor or hardware information from the device

C. To reset the device hardware

D. To format the device memory

Solution

1. Step 1: Understand I2C device communication

   I2C devices often provide sensor or hardware data that the program needs to read.

2. Step 2: Identify the purpose of reading data

   Reading data means fetching information like sensor values, not sending commands or resetting.

3. Final Answer:

   To get sensor or hardware information from the device -> Option B

4. Quick Check:

   Reading I2C = Getting device data [OK]

Hint: Reading I2C means fetching data from device [OK]

Common Mistakes:

• Confusing reading with sending commands
• Thinking reading resets the device
• Assuming reading formats memory

2. Which of the following is the correct way to declare a buffer to read 4 bytes from an I2C device in embedded C?

easy

A. int buffer[1];

B. int buffer = 4;

C. char buffer;

D. char buffer[4];

Solution

1. Step 1: Understand buffer declaration for byte storage

   To store multiple bytes, we need an array of chars (bytes) of size 4.

2. Step 2: Check each option

   char buffer[4]; declares a char array of size 4, suitable for 4 bytes. Others are either single variables or wrong types.

3. Final Answer:

   char buffer[4]; -> Option D

4. Quick Check:

   Buffer for 4 bytes = char array size 4 [OK]

Hint: Use char array for byte buffers [OK]

Common Mistakes:

• Using single char instead of array
• Using int for byte buffer
• Declaring wrong array size

3. Given this code snippet, what will be the value of result after reading 2 bytes from the I2C device?

uint8_t buffer[2];
int result = i2c_read(device_addr, reg_addr, buffer, 2);

Assume i2c_read returns 0 on success and -1 on failure.

medium

A. 0

B. -1

C. 2

D. Undefined

Solution

1. Step 1: Understand i2c_read return values

   The function returns 0 if the read was successful, -1 if it failed.

2. Step 2: Analyze the code snippet

   The code reads 2 bytes and stores in buffer. If successful, result = 0.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   Success return = 0 [OK]

Hint: i2c_read returns 0 on success [OK]

Common Mistakes:

• Assuming return is number of bytes read
• Confusing success with failure codes
• Ignoring return value meaning

4. Identify the error in this code snippet for reading 1 byte from an I2C device:

uint8_t data;
int status = i2c_read(device_addr, reg_addr, &data, 1);
if (status = 0) {
    process(data);
}

medium

A. Using assignment (=) instead of comparison (==) in if condition

B. Incorrect buffer type for reading data

C. Missing initialization of device_addr

D. Wrong number of bytes requested

Solution

1. Step 1: Check the if condition syntax

   The condition uses single '=' which assigns 0 instead of comparing.

2. Step 2: Understand effect of assignment in if

   Assignment returns 0 (false), so process(data) never runs even on success.

3. Final Answer:

   Using assignment (=) instead of comparison (==) in if condition -> Option A

4. Quick Check:

   Use '==' for comparison in if [OK]

Hint: Use '==' to compare, not '=' in conditions [OK]

Common Mistakes:

• Confusing '=' and '==' in if statements
• Ignoring return status check
• Not using address-of operator for buffer

5. You want to read 3 bytes from an I2C device register and combine them into a 24-bit integer. Which code snippet correctly reads and combines the data?

uint8_t buf[3];
int status = i2c_read(device_addr, reg_addr, buf, 3);
uint32_t value = ???;

hard

A. value = buf[0] | (buf[1] << 8) | (buf[2] << 16);

B. value = (buf[2] << 16) | (buf[1] << 8) | buf[0];

C. value = (buf[0] << 16) | (buf[1] << 8) | buf[2];

D. value = buf[0] + buf[1] + buf[2];

Solution

1. Step 1: Understand byte order for 24-bit integer

   Assuming buf[0] is most significant byte, shift it left by 16 bits.

2. Step 2: Combine bytes with bitwise OR

   Shift buf[1] by 8 bits, add buf[2] as least significant byte.

3. Step 3: Check each option

   value = (buf[0] << 16) | (buf[1] << 8) | buf[2]; correctly combines bytes in big-endian order. Others mix order or sum bytes incorrectly.

4. Final Answer:

   value = (buf[0] << 16) | (buf[1] << 8) | buf[2]; -> Option C

5. Quick Check:

   Shift and OR bytes for 24-bit value [OK]

Hint: Shift bytes by 16, 8, 0 bits and OR [OK]

Common Mistakes:

• Mixing byte order
• Adding bytes instead of bitwise OR
• Not shifting bytes correctly