I2C addressing (7-bit and 10-bit) in Embedded C - Mini Project: Build & Apply

I2C Addressing (7-bit and 10-bit)

📖 Scenario: You are working on a small embedded system that communicates with sensors using the I2C protocol. Each sensor has an address that can be either 7-bit or 10-bit. You need to prepare the addresses correctly before sending them on the I2C bus.

🎯 Goal: Build a simple C program that stores I2C device addresses, distinguishes between 7-bit and 10-bit addresses, and prepares the addresses for communication by shifting them as required.

📋 What You'll Learn

Create an array of device addresses with both 7-bit and 10-bit values

Create a variable to hold the number of devices

Write a loop to process each address and prepare it for I2C communication

Print the original and prepared addresses for each device

💡 Why This Matters

🌍 Real World

Embedded systems often communicate with sensors and devices using I2C. Correctly preparing device addresses is essential for reliable communication.

💼 Career

Understanding I2C addressing and bit manipulation is important for embedded software engineers working with microcontrollers and hardware interfaces.

1

Create the I2C device addresses array

Create an array called device_addresses of type unsigned int with these exact values: 0x3C (7-bit), 0x1FF (10-bit), 0x50 (7-bit), and 0x2AA (10-bit).

Embedded C

# Create the device_addresses array with the given values
// Your code here

Hint

Use curly braces to list the values inside the array.

2

Create a variable for the number of devices

Create an int variable called num_devices and set it to the number of elements in the device_addresses array.

Embedded C

unsigned int device_addresses[] = {0x3C, 0x1FF, 0x50, 0x2AA};
// Create num_devices to hold the number of devices
// Your code here

Hint

Use sizeof to calculate the number of elements in the array.

3

Prepare addresses for I2C communication

Write a for loop using int i from 0 to num_devices - 1. Inside the loop, create an unsigned int variable called prepared_address. If the address is 7-bit (less than 128), shift it left by 1 bit. If it is 10-bit (128 or more), shift it left by 1 bit and set bit 0 to 1. Use device_addresses[i] to get the current address.

Embedded C

unsigned int device_addresses[] = {0x3C, 0x1FF, 0x50, 0x2AA};
int num_devices = sizeof(device_addresses) / sizeof(device_addresses[0]);
// Loop through device_addresses and prepare each address
// Your code here

Hint

Use bitwise shift << and bitwise OR | operators.

4

Print original and prepared addresses

Inside the for loop, add a printf statement to print the original address and the prepared address in hexadecimal format. Use 0x%X format specifier. Print exactly like this: Original: 0x3C, Prepared: 0x78 for each device.

Embedded C

unsigned int device_addresses[] = {0x3C, 0x1FF, 0x50, 0x2AA};
int num_devices = sizeof(device_addresses) / sizeof(device_addresses[0]);

for (int i = 0; i < num_devices; i++) {
    unsigned int prepared_address;
    if (device_addresses[i] < 128) {
        prepared_address = device_addresses[i] << 1;
    } else {
        prepared_address = (device_addresses[i] << 1) | 1;
    }
    // Print original and prepared addresses
    // Your code here
}

Hint

Use printf("Original: 0x%X, Prepared: 0x%X\n", device_addresses[i], prepared_address); inside the loop.

Practice

1.

What is the size of the standard I2C address used to identify devices?

easy

A. 7 bits

B. 8 bits

C. 10 bits

D. 16 bits

Solution

1. Step 1: Understand I2C addressing basics

   I2C commonly uses 7-bit addresses to identify devices on the bus.

2. Step 2: Recall standard address size

   The standard I2C address size is 7 bits, while 10-bit is an extended mode.

3. Final Answer:

   7 bits -> Option A

4. Quick Check:

   Standard I2C address = 7 bits [OK]

Hint: Remember standard I2C uses 7-bit addresses [OK]

Common Mistakes:

• Confusing 7-bit with 8-bit addresses
• Thinking 10-bit is the default
• Assuming 16-bit addresses exist in I2C

2.

Which of the following is the correct way to prepare a 7-bit I2C address for a write operation in embedded C?

uint8_t address = 0x3C; // 7-bit address
uint8_t write_address = ?;

easy

A. write_address = address << 2;

B. write_address = (address >> 1) | 1;

C. write_address = address | 0x80;

D. write_address = (address << 1) | 0;

Solution

1. Step 1: Shift 7-bit address left by 1

   The 7-bit address must be shifted left by 1 to make room for the read/write bit.

2. Step 2: Set read/write bit for write operation

   For write, the least significant bit is 0, so OR with 0.

3. Final Answer:

   write_address = (address << 1) | 0; -> Option D

4. Quick Check:

   Shift left 1 + write bit 0 = correct address [OK]

Hint: Shift left by 1, OR with 0 for write [OK]

Common Mistakes:

• Shifting right instead of left
• Setting read/write bit incorrectly
• Using wrong bitwise OR values

3.

Given the following code snippet, what is the value of header for a 10-bit I2C address 0x305?

uint16_t addr = 0x305;
uint8_t header = 0xF0 | ((addr >> 7) & 0x06) | 0x00; // write operation

medium

A. 0xF6

B. 0xF0

C. 0xF2

D. 0xF4

Solution

1. Step 1: Analyze addr = 0x305

   Binary 0b1100000101 (bits 9-0: bit9=1, bit8=1, bit7=0). Shift right 7: 0b110 (6).

2. Step 2: Mask and compute header

   (6 & 0x06) = 0x06. Then 0xF0 | 0x06 | 0x00 = 0xF6.

3. Final Answer:

   0xF6 -> Option A

4. Quick Check:

   0xF0 | ((0x305 >> 7) & 0x06) = 0xF6 [OK]

Hint: Shift address right 7, mask with 0x06, OR with 0xF0 [OK]

Common Mistakes:

• Not shifting address before masking
• Incorrect mask value
• Confusing read/write bit in header

4.

Identify the error in this code snippet for sending a 10-bit I2C address:

uint16_t addr = 0x3FF;
uint8_t header = 0xF0 | ((addr >> 7) & 0x06) | 0x01; // read operation
uint8_t low_addr = addr & 0xFF;
// send header and low_addr over I2C

medium

A. The read/write bit in header should be 0 for read

B. The low_addr should be shifted left by 1 before sending

C. The header calculation is correct; no error

D. The mask 0x06 should be 0x07 to include all bits

Solution

1. Step 1: Check read/write bit in header

   For read operation, the last bit is set to 1, which matches the code.

2. Step 2: Verify mask and low address

   Mask 0x06 correctly extracts bits 7 and 8; low_addr is the lower 8 bits, no shift needed.

3. Final Answer:

   The header calculation is correct; no error -> Option C

4. Quick Check:

   Header and low_addr correct for 10-bit read [OK]

Hint: Check read/write bit and mask carefully [OK]

Common Mistakes:

• Confusing read/write bit value
• Incorrect mask for bits 7 and 8
• Shifting low address unnecessarily

5.

You need to write a function in embedded C that takes a 10-bit I2C address and returns the two bytes to send: the header byte and the low address byte for a write operation. Which of the following implementations is correct?

void get_i2c_10bit_bytes(uint16_t addr, uint8_t *header, uint8_t *low_addr) {
    // ?
}

hard

A. header = 0xF0 | ((addr >> 7) & 0x06) | 0x00; low_addr = addr & 0xFF;

B. *header = 0xF0 | ((addr >> 7) & 0x06) | 0x00; *low_addr = addr & 0xFF;

C. *header = 0xF0 | ((addr << 7) & 0x06) | 0x00; *low_addr = addr >> 8;

D. header = 0xF0 | ((addr >> 7) & 0x07) | 0x01; low_addr = addr & 0xFF;

Solution

1. Step 1: Use pointers to assign output values

   The function parameters header and low_addr are pointers, so use * to assign values.

2. Step 2: Calculate header and low_addr correctly

   Header is 0xF0 ORed with bits 7 and 8 of addr shifted right 7, and OR 0 for write; low_addr is lower 8 bits.

3. Final Answer:

   *header = 0xF0 | ((addr >> 7) & 0x06) | 0x00; *low_addr = addr & 0xFF; -> Option B

4. Quick Check:

   Pointer dereference + correct bit ops = correct function [OK]

Hint: Use * to assign pointer outputs, shift right 7 bits [OK]

Common Mistakes:

• Not using * to assign pointer values
• Shifting bits incorrectly
• Setting read/write bit wrong